Gumawa ng mga pipeline gamit ang PowerShell 7 at ForEach-Object -Parallel

Kapag nagsimula kang gumamit ng PowerShell, maaga o huli ay makakaranas ka ng parehong problema: mayroon ka maraming bagay na ipoproseso sa isang loop at bumababa ang performance. Halimbawa, ang mga exchange mailbox, file sa isang server, at mga proseso sa maraming makina para sa pamahalaan ang maraming PC at server...lahat ay dumadaan sa pipeline at sa klasiko ForEach-ObjectPero, siyempre, ang loop na iyon ay sunod-sunod, bawat elemento, at darating ang punto kung saan ito ay nagkukulang.

Sa pagdating ng PowerShell 7, malaki ang ipinagbago ng sitwasyon. Mayroon na tayong parallel pipelining na magagamit gamit ang `ForEach-Object -Parallel` at iba pang mga concurrency approach na nagbibigay-daan sa atin na mas mahusay na magamit ang mga CPU core at mabawasan ang oras ng paghihintay ng mga operasyon sa network o disk. Ang sekreto ay lubos na maunawaan kung ano ang ginagawa ng bawat opsyon, kung kailan ito angkop gamitin, at kung paano limitahan ang concurrency upang hindi bumaba ang performance sa halip na mapabuti ito.

Mga loop sa PowerShell: ang panimulang punto

Bago tayo sumisid sa mga parallel pipeline, makakatulong na maunawaan kung ano ang mga loop at kung paano kumikilos ang iba't ibang PowerShell construct. Sa esensya, ang loop ay isang paraan upang ulitin ang isa o higit pang mga tagubilin nang maraming beses , alinman para sa isang kilalang bilang ng mga iterasyon o habang natutugunan ang isang kundisyon. Sa pangangasiwa ng system, karaniwan ito: mula sa paglalapat ng mga pahintulot sa lahat ng mga user sa isang grupo hanggang sa pagtawid sa libu-libong mga file sa isang direktoryo o pagproseso ng mga kaganapan gamit ang Get-WinEvent.

Nag-aalok ang PowerShell ng ilang klasikong istruktura ng kontrol tulad ng for, foreach, while, do-while y do-until, bilang karagdagan sa mga cmdlet at mga pamamaraan na nagpapahintulot din sa pag-ulit, tulad ng ForEach-Object o ang pamamaraan .ForEach() sa mga koleksyon. Lahat ng mga ito ang bumubuo ng batayan kung saan maaari tayong bumuo ng mas advanced na lohika, kabilang ang parallel execution.

foreach vs ForEach-Object vs ForEach na pamamaraan

Sa PowerShell, may kaunting kalituhan dahil mayroon tayong tatlong magkakaibang paraan para gawin ang "foreach," at hindi sila pareho ang kilos. Sa sintaks, magkatulad sila, ngunit sa loob ay medyo nagbabago ang mga bagay-bagay, lalo na pagdating sa paggamit ng memorya at sa pipeline.

foreach keyword (foreach statement)

Ang susing salita foreach Ito ang "klasikong" loop construct ng wika. I-load ang Ang buong koleksyon ay nakaimbak sa memorya at ang bawat elemento ay sinusubaybayan nang sunud-sunod.Ito ay maginhawa at napakabilis kapag mayroon ka nang array o iba pang koleksyon sa memorya at makatwiran ang laki nito. Ang pagproseso ay sumusunod sa mga hakbang na ito: una, tinutukoy ng PowerShell kung gaano karaming elemento ang mayroon, pagkatapos ay itinatalaga nito ang bawat elemento, isa-isa, sa isang variable (halimbawa, $item) at isinasagawa ang code block para sa bawat iterasyon.

Ang pamamaraang ito ay mainam kapag nagtatrabaho sa mga mahusay na tinukoy na in-memory na koleksyon , tulad ng isang listahan ng mga proseso, isang hanay ng mga ruta, o isang hanay ng mga numero. Gayunpaman, hindi ito idinisenyo para sa direktang pagbabasa mula sa pipeline, at kung ang koleksyon ay napakalaki, maaari itong kumonsumo ng malaking halaga ng memorya.

Ang cmdlet na ForEach-Object ay nasa pipeline

Ang cmdlet ForEach-Object Iba ang paggana nito: dinisenyo ito upang iproseso ang isang bagay sa isang pagkakataon habang dumarating ito sa pamamagitan ng pipelineSa madaling salita, hindi nito kailangang i-load ang buong koleksyon mula sa simula. Ginagawa nitong napaka-epektibo para sa mga sitwasyon kung saan ang pinagmumulan ng data ay maaaring makabuo ng maraming item (halimbawa, Get-ChildItem (sa isang malaking puno ng folder) o kapag ayaw mo o hindi mo maiimbak ang buong koleksyon sa memorya, o kapag gumagamit ng mga panlabas na tool tulad ng Git mula sa PowerShell.

Kapalit, Mayroon itong bahagyang labis na karga dahil sa mekanismo ng pipeline mismo at karaniwang medyo mas mabagal kaysa sa keyword foreach kapag pareho itong gumagana sa iisang koleksyon sa memorya. Gayunpaman, nakakakuha ito ng mga puntos sa scalability at kahusayan ng memorya, na sa mga kapaligiran ng produksyon ay karaniwang mas mahalaga kaysa sa pagpigil ng ilang millisecond ng bilis bawat bagay.

Paraan ng ForEach() sa mga koleksyon

Simula noong PowerShell 5, maraming koleksyon tulad ng mga array at listahan ang naglalantad sa pamamaraan .ForEach(), na nagpapahintulot Maglagay ng scriptblock sa bawat elemento sa isang napakaikling paraan. Halimbawa, $array.ForEach({ ... })Ang pamamaraang ito ay object-oriented at lubhang kapaki-pakinabang kapag gusto mong i-chain ang mga operasyon at gumana nang maayos sa mga dati nang koleksyon.

Sa usapin ng pagganap, ang pamamaraan .ForEach() kadalasan mas mahusay kaysa sa cmdlet na ForEach-Object Kapag ang lahat ay nasa memorya na, dahil iniiwasan mo ang bahagi ng pipeline mechanics. Gayunpaman, mayroon pa rin itong parehong pangunahing limitasyon: gumagana ito sa mga koleksyon na na-materialize na, kaya hindi ito ang tamang tool para sa pag-stream ng malalaking volume ng data.

Mga praktikal na pagkakaiba sa pagitan ng foreach at ForEach-Object

Sa pang-araw-araw na gawain, lumilitaw ang mga tanong tulad ng: "Bakit ganito script Estados Unidos Get-Mailbox ... | ForEach-Object { ... } at isa pa ang unang gumagawa nito $Mailboxes = Get-Mailbox ... at pagkatapos ay a foreach ($Mailbox in $Mailboxes)Ang pangunahing pagkakaiba ay sa unang kaso Lahat ay dumadaan sa isang pipeline, pinoproseso ang bawat mailbox pagdating nito, habang sa pangalawa ang buong koleksyon ay nakaimbak sa variable $Mailboxes at pagkatapos ay maglakbay ka sa paligid.

Ang pagpili ay hindi lamang usapin ng istilo: kung humahawak ka ng libu-libong elemento, ang paggamit ng memorya at paghawak ng error ay maaaring mag-iba nang malaki, at sa kasong ito, ang pipeline ay karaniwang mas madaling gamitin, kapalit ng bahagyang pagkawala ng pagganap sa bawat object.

Iba pang uri ng mga loop: for, while, do-while, do-until

Bukod sa foreach ecosystem, kasama sa PowerShell ang iba pang tradisyonal na loop na nananatiling lubhang kapaki-pakinabang. Ang foreach loop for nagpapahintulot sa pag-ulit sa isang hanay ng mga numeroMagandang ideya ang pagdaragdag o pagbabawas ng isang index hanggang sa hindi na matugunan ang isang kundisyon. Perpekto ito para sa pagtawid sa mga array ayon sa posisyon, paglaktaw ng mga elemento, o pag-access sa mga ito nang pabaliktad.

Ang mga loop do-while y do-until Pinapatay nila ang katawan nang kahit isang beses at pagkatapos ay sinusuri nila ang kondisyon: sa do-while inuulit ito hangga't natutupad, at sa do-until Umuulit ito hanggang sa matugunan ang kundisyon. Ang mga ito ay lubhang kapaki-pakinabang kapag kailangan mong isagawa ang bloke nang kahit isang beses, halimbawa, kapag humihiling ng data mula sa gumagamit o sinusubukan ang isang mapagkukunan hanggang sa tumugon ito nang tama.

Loop while suriin ang kondisyon sa simula pa langKung hindi matutugunan ang kundisyon, hindi ito papasok sa sistema. Ito ang klasikong "hangga't nananatiling totoo ito" na alam nating lahat mula sa ibang mga wika. Sa mga gawain sa automation, maaari itong gamitin upang subaybayan ang isang serbisyo, isang numerical value, o ang estado ng isang resource hanggang sa maabot ang isang layunin.

Kontrol ng pinong daloy: putulin, ipagpatuloy at ibalik

Para mas mahusay na makontrol ang nangyayari sa loob ng mga loop, mayroon kaming tatlong pangunahing keyword: break, continue y returnBagama't kung minsan ay nakaliligtaan, malaki ang nagagawang pagkakaiba ng mga ito sa mga kumplikadong script.

Ang pagtuturo break Pinapayagan ka nitong lumabas agad sa loop. kasalukuyan. Ito ay lubhang kapaki-pakinabang kapag tinatahak mo ang isang array o isang listahan na naghahanap ng isang bagay na partikular: sa sandaling matagpuan mo ito, gagawin mo break at naiiwasan mo ang paulit-ulit na pag-uulit nang hindi kinakailangan.

Ang salita continue tumalon sa susunod na loop iterationhindi pinapansin ang iba pang mga tagubilin sa kasalukuyang iterasyon. Madalas itong ginagamit upang "i-filter" ang mga elemento: kung ang isang bagay ay hindi nakakatugon sa isang kundisyon, gagawin mo continue at talagang pinoproseso mo lamang ang mga bagay na interesado ka.

Sa wakas, return hindi lang basta sinisira ang loopHindi lamang ito nagbabalik ng halaga mula sa isang function o script, kundi nagbabalik din ito ng halaga. Parang sinasabi mong, "Nakuha ko na ang hinahanap ko, narito na, at aalis na ako." Kung gagamitin nang matalino, lubos nitong pinapasimple ang lohika ng script.

Para sa Bawat-Bagay -Parallel sa PowerShell 7

Ipinakilala ng PowerShell 7 ang isang napakalakas na bagong tampok: ang parameter -Parallel ng cmdlet ForEach-ObjectAng functionality na ito, na unang idinagdag sa beta 3 ng bersyon 7.0, ay nagbibigay-daan sa pagproseso ng ilang elemento ng pipeline nang sabay-sabay, nang hindi kinakailangang gumamit ng mga panlabas na module o kumplikadong code na may mga runspace.

Simple lang ang ideya: sa halip na iproseso ang isang bagay pagkatapos ng isa pa nang sunud-sunod , ang cmdlet ay maaaring magpatakbo ng maraming iterasyon nang sabay-sabay, bawat isa ay nagpapatupad ng script block sa ibang elemento ng koleksyon. Sa ganitong paraan, kung mayroon kang mga independiyenteng gawain (tulad ng maraming kahilingan sa HTTP, maraming kopya ng file sa iba't ibang destinasyon, o mga query laban sa maraming mailbox), maaari mong mabawasan nang malaki ang kabuuang oras ng pagpapatupad.

Pag-uugali ng ForEach-Object bago at pagkatapos ng -Parallel

Kung wala ang parametro -Parallel, Pinoproseso ng ForEach-Object ang mga elemento ayon sa pagkakasunod-sunodIsa-isa, hinihintay na matapos ang bawat bloke bago lumipat sa susunod. Kung gagawa ka ng isang simpleng pagsubok na may 10 bagay at isang maikling artipisyal na paghinto, makikita mo na ang kabuuang oras ay halos kabuuan ng 10 indibidwal na beses.

Pag-activate -Parallel Ang parehong code ay maaaring isagawa nang ilang beses nang mas mabilis.Ito ay dahil ang mga iterasyon ay ipinamamahagi sa ilang mga subproseso. Isang tipikal na halimbawa: ang tumatagal ng humigit-kumulang 10 segundo sa sequential mode ay maaaring bumaba sa wala pang 3 segundo nang parallel, depende sa bilang ng sabay-sabay na mga gawain at ang uri ng trabahong ginagawa mo sa loob ng block.

Pagkakasunod-sunod ng paglabas at bilang ng sabay-sabay na operasyon

May isang mahalagang detalye: kapag ginamit mo ForEach-Object -Parallel, Ang Hindi na garantisado ang pagkakasunod-sunod ng mga resulta.Ibinabalik ang mga aytem kapag nakumpleto na ang mga gawain, hindi sa orihinal nitong pagkakasunod-sunod. Kung ang iyong lohika ay nakadepende sa pagkakasunod-sunod, kakailanganin mong baguhin ang pagkakasunod-sunod pagkatapos o magsama ng impormasyon sa index upang muling buuin ito.

Bilang default, tumatakbo ang PowerShell 7 limang sabay-sabay na operasyonKung kailangan mong ayusin ito, gamitin ang parameter na ThrottleLimitTinutukoy nito ang pinakamataas na bilang ng mga elemento na maaaring iproseso nang sabay-sabay. Ang wastong pag-configure nito ay susi sa paghahanap ng tamang balanse sa pagitan ng bilis at pagkonsumo ng mapagkukunan.

Kailan hindi ipinapayong mag-parallelize?

Hindi lahat ng problema ay nalulutas sa pamamagitan ng walang pinipiling pagpapatupad ng parallelism. Sa ilang mga sitwasyon, tulad ng malalaking paglilipat ng file sa isang limitadong network , ang pagpapatakbo ng napakaraming parallel operations ay maaaring mag-saturate ng bandwidth at makabalighuan na nagpapabagal sa lahat. Ganito rin ang naaangkop sa mga API o remote service na may mga limitasyon sa kahilingan.

Sa ibang mga kaso, tulad ng mga operasyon na mahigpit na nakadepende sa pagkakasunud-sunod ng pagpapatupad o nagbabago sa parehong pinagsasaluhang mapagkukunan , ang paralelismo ay maaaring magdulot ng mga kondisyon ng karera o mga hindi pagkakapare-pareho. Sa mga kontekstong ito, karaniwang mas mainam na manatili sa isang sunud-sunod na pamamaraan o maglapat ng mas detalyado at kontroladong paralelismo.

Iba pang mga opsyon para sa pagpapatakbo nang parallel sa PowerShell

At ForEach-Object -Parallel, nag-aalok ang PowerShell ilang paraan para gumana nang sabay-sabayPareho sa mga mas lumang bersyon at sa sangay na 7.x. Bawat isa ay may mga kalamangan at kahinaan, at mahalagang malaman ang mga ito upang mapili ang tamang tool.

Start-Job: mga trabaho sa mga independiyenteng proseso

Ang cmdlet Start-Job Ito ay umiiral sa lahat ng bersyon ng PowerShell at inilulunsad gumagana sa magkakahiwalay na proseso, bawat isa ay may sariling instance ng PowerShellNagbibigay ito ng malakas na paghihiwalay, ngunit marami itong overhead: paglikha ng mga bagong proseso, pag-serialize at pag-deserialize ng mga bagay pabalik, atbp.

Sa maraming sitwasyon, maaaring magresulta ang isang sunod-sunod na pag-ikot mas mabilis kaysa sa pag-abuso sa Start-Joblalo na kapag maikli ang mga gawain o nagbabalik ng malalaking dami ng kumplikadong datos. Bukod pa rito, Start-Job hindi kasama bilang pamantayan ang isang ThrottleLimitSamakatuwid, kailangan mong pamahalaan kung gaano karaming trabaho ang sabay-sabay na tatakbo.

Start-ThreadJob: mga trabahong nakabatay sa thread

Ang modyul Trabaho sa Thread nagbibigay ng cmdlet Start-ThreadJobna gumagamit ng mga runspace upang lumikha mas magaan na trabaho kaysa sa mga nasa Start-JobSa pamamagitan ng pagbabahagi ng proseso, marami sa mga pagkawala ng impormasyon ng uri na dulot ng serialization sa pagitan ng mga proseso ay naiiwasan.

Sa PowerShell 7 at mga mas bagong bersyon, kasama na ang ThreadJob module, habang nasa Windows Maaaring i-install ang PowerShell 5.1 mula sa PowerShell Gallery. Sinusuportahan ng Start-ThreadJob ang parameter na ThrottleLimitNagbibigay-daan ito sa iyong kontrolin kung ilan sa mga trabahong ito ang tatakbo nang sabay-sabay, na pumipigil sa iyo na maubos ang mga mapagkukunan ng system.

Mga Runspace at SDK ng PowerShell

Para sa mga advanced na senaryo, maaari kang direktang gumamit ng namespace System.Management.Automation.Runspaces mula sa PowerShell SDK. Nagbibigay-daan ito sa iyo na lumikha ng sarili mong napakahusay na parallelism logic, na kumokontrol sa pamamahala ng mga runspace, pool, synchronization, atbp. Sa katunayan, pareho ForEach-Object -Parallel bilang Start-ThreadJob Umaasa sila sa loob ng kumpanya sa mga runspace.

Ang pamamaraang ito ay nag-aalok ng pinakamataas na kakayahang umangkop at potensyal na pagganap , ngunit nagsasangkot din ito ng mas maraming pagiging kumplikado at "plumbing" code. Sa maraming pagkakataon, ang mga built-in na cmdlet (ForEach-Object-Parallel at Start-ThreadJob) ay sumasaklaw sa karamihan ng mga pangangailangan, na nag-aalis ng pangangailangan para sa ganitong pagiging kumplikado.

Mga daloy ng trabaho at foreach -Parallel sa Windows PowerShell

Ang Windows PowerShell 5.1 ay may kakayahang WorkflowsIsang espesyal na uri ng script na idinisenyo para sa mga pangmatagalang gawain, na may kakayahang mag-pause, magpatuloy, at tumakbo nang sabay-sabay. Sa loob ng isang daloy ng trabaho, maaaring gamitin ang construct foreach -ParallelNa isagawa ang script block nang isang beses para sa bawat elemento sa isang koleksyon nang sabay-sabay.

Ang pangunahing syntax ng foreach -Parallel ito ay isang bagay tulad ng foreach -Parallel ($item in $collection) { ... }, At Ito ay may bisa lamang sa loob ng isang daloy ng trabahoAng mga elemento ng koleksyon ay pinoproseso nang sabay-sabay, habang ang comandos sa loob ng bloke, ang mga ito ay isinasagawa nang sunud-sunod para sa bawat elemento (bagaman maaari rin itong pagsamahin sa mga bloke) parallel { ... } panloob).

Gayunpaman, ang mga daloy ng trabaho Hindi available ang mga ito sa PowerShell 7 o mas bagong mga bersyonHindi rin inirerekomenda ang mga ito para sa mga bagong development. Gayunpaman, mahalagang maunawaan ang syntax at konsepto kung nagpapanatili ka ng mga legacy script na gumagamit ng mga ito. foreach -Parallel, dahil ang kilos nito ay naiiba sa normal na foreach at ForEach-Object -Parallel.

Limitahan ang sabay-sabay na paggamit ng ThrottleLimit

Hindi porket maaaring tumakbo nang sabay-sabay ang isang bagay ay mas mabilis na ito. Sa katunayan, ang mga aplikasyon na masinsinang gumagamit ng I/O o mga magaan na script ay maaaring magdusa ng pagkawala ng performance kung napakaraming sabay-sabay na gawain , maaaring dahil sa CPU, disk, o network overload, o dahil lamang sa overhead ng pamamahala ng napakaraming thread nang sabay-sabay.

Upang balansehin ang aspetong ito, Start-ThreadJob y ForEach-Object -Parallel Nag-aalok sila ng parameter ThrottleLimitItinatakda nito ang pinakamataas na bilang ng mga trabaho o pag-ulit na maaaring patakbuhin nang sabay-sabay. Kung susubukan mong maglunsad ng higit pang mga trabaho kaysa sa pinapayagan, ilalagay ang mga ito sa pila hanggang sa matapos ang isa at magkaroon ng espasyo.

Simula noong PowerShell 7.1, ForEach-Object -Parallel muling ginagamit ang mga runspace mula sa isang default na pool, at ang halaga ng ThrottleLimit tinutukoy ang laki ng pool na iyon. Ang default na halaga ay 5, na karaniwang isang magandang panimulang punto. Mayroon ding modifier para lumikha ng bagong runspace para sa bawat iteration (UseNewRunspace), ngunit sulit lamang ito kapag kailangan mo ng napakalakas na insulasyon at tinatanggap ang mas maraming overloading.

Sa kabilang banda ang cmdlet Start-Job kulang sa ThrottleLimitSamakatuwid, kung hindi mo ito mano-manong kokontrolin, maaari kang magkaroon ng dose-dosenang o daan-daang proseso ng PowerShell na tumatakbo nang sabay-sabay, na may kaukulang epekto sa performance at memory.

Pagsukat ng pagganap ng iba't ibang pamamaraan

Isang makatwirang paraan upang magpasya kung aling modelo ng paralelismo ang gagamitin ay Sukatin ang aktwal na oras ng pagpapatupad para sa iyong use casePara gawin ito, maaari mong gamitin ang isang function tulad ng Measure-Parallel, na naghahambing sa bilis ng ilang mga pamamaraan: Start-Job, Start-ThreadJob, ForEach-Object -Parallel y Start-Process.

Ang tungkuling ito ay lumilikha ng isang kunwaring koleksyon ng mga input (hal., mga pangalan ng ZIP file), bumubuo ng ilang "batch" o mga sesyon ng trabaho, at, para sa bawat pamamaraan, sinusukat kung gaano katagal ang pagproseso ng isang ibinigay na bilang ng mga elemento, na may laki ng batch na na-configure ni BatchSize at isang kabuuang bilang ng mga gawa JobCountInaangkop din nito ang mga magagamit na pamamaraan depende sa bersyon ng PowerShell at ang pagkakaroon o kawalan nito. Start-ThreadJob.

Sa loob, Measure-Parallel i-configure ang isang executable (tulad ng cmd.exe o shna may listahan ng mga argumento, at tumutukoy sa isang hashtable na may mga implementasyon na partikular sa bawat diskarte. Measure-Command kalkulahin ang kabuuang oras Sa pamamagitan ng pagproseso ng lahat ng batch para sa bawat alternatibo, pinapayagan ka nitong makita ang mga detalyadong mensahe na may -Verbose At panghuli, ibinabalik nito ang isang bagay na may buod ng mga oras upang madali itong maihambing.

Pagpapatakbo ng isang bagay tulad ng Measure-Parallel -Approach All -BatchSize 5 -JobCount 20 -Verbose Sa isang Windows computer na may PowerShell 7.5.1, mapapansin na, sa partikular na kasong iyon, Start-Process makuha ang pinakamaikling orasmalapit na sinundan ng ForEach-Object -Parallel y Start-ThreadJobHabang Start-Job Ito pala ang pinakamabagal na opsyon dahil sa malaking gastos na kakailanganin sa paglulunsad ng mga child process ng PowerShell.

Paralelismo at "tradisyonal" na mga loop sa harap

Isang bagay na madalas mangyari sa pagsasagawa ay, habang inililipat mo ang mga lumang workflow at script sa PowerShell 7, nagsisimula kang palitan ang mga manu-manong runspace, mga third-party module tulad ng PoshRSJob o Workflows sa pamamagitan ng mga kagamitang nakapaloob na, tulad ng Start-ThreadJob y ForEach-Object -ParallelPinapasimple nito ang code at binabawasan ang bilang ng mga panlabas na dependency. Karaniwan din ang pagsasama ng mga solusyon sa automation tulad ng PowerShell DSC.

May mga administrador na gumagamit ng mga manual runspace pool ngunit nagsimulang makaranas ng hindi matatag na pag-uugali (halimbawa, mga script na random na nagtatapos sa mga production environment) at, dahil sa kahirapan sa pag-debug ng mga problemang ito, pinili nilang bawasan ang pagiging kumplikado at umasa sa mga integrated parallel functionality na nasubukan at sinusuportahan na ng mismong PowerShell team.

Mga advanced na pamamaraan gamit ang foreach: nesting, filtering, at error handling

Higit pa sa paralelismo, ang mga loop Pinapayagan ka ng foreach na bumuo ng napakayamang lohika kapag pinagsama-sama mo ang mga pangungusap if, pag-pugad ng loop at paghawak ng exception.

Sa loob ng a foreach Karaniwang gamitin ang mga kondisyon if iproseso ang mga elemento nang iba batay sa kanilang mga katangian. Halimbawa, pag-ulit sa lahat ng mga file sa isang direktoryo at pagkilos lamang sa mga lumalagpas sa isang tiyak na laki, pagkopya sa mga ito sa ibang lokasyon, pag-compress sa mga ito, o pagbura sa mga ito kung natutugunan nila ang ilang mga kinakailangan sa edad.

Maaari ka ring mag-nest ng mga loop foreach para bumuo ng mga kombinasyon ng mga elemento mula sa ilang koleksyonHalimbawa, mga listahan ng parameter ng pagsubok, mga produktong Cartesian sa pagitan ng mga numero at letra, o mga two-dimensional na pagtawid ng datos. Sa kasong ito, mahalagang huwag gamitin muli ang parehong pangalan ng baryabol sa panloob at panlabas na mga loop upang maiwasan ang kalituhan at mga banayad na pagkakamali.

Tungkol sa paghawak ng error, kung ang isang foreach ay nakatagpo ng isang hindi ginamot na eksepsiyon, Posibleng matigil ang buong iskrip.na hindi laging kanais-nais. Ang karaniwang paraan upang palakasin ang loop ay ang pagbalot ng internal logic sa isang block. try { ... } catch { ... }Kaya, kung may magkamali para sa isang partikular na item, maaari mong i-log ang error at magpatuloy sa natitirang bahagi ng koleksyon nang hindi hinihinto ang buong pagpapatupad.

Mga karaniwang pagkakamali at pinakamahusay na kasanayan sa foreach

May ilang karaniwang problema kapag gumagamit ng foreach loops sa PowerShell . Isa na rito ang paggamit ng parehong pangalan ng variable sa mga nested loops, na nagiging sanhi ng pag-overwrite ng inner value sa outer value at pagbunga ng mga hindi inaasahang resulta. Simple lang ang solusyon: gumamit ng iba't ibang pangalan para sa bawat antas ng nesting.

Ang isa pang karaniwang pagkakamali ay abusar de break nang hindi pinag-iisipanDahil dito, natatapos ang loop bago pa man maproseso ang buong koleksyon, gayong ang layunin ay laktawan lamang ang ilang elemento. Sa maraming pagkakataon continue Mas angkop ito dahil pinapayagan ka nitong laktawan ang mga partikular na pag-ulit nang hindi lubusang iniiwan ang loop.

Kailangan mo ring maging maingat sa mga infinite loop, lalo na kapag binabago ang parehong koleksyon na iyong inuulit . Kung magdadagdag ka ng mga elemento sa parehong array nang walang anumang kontrol habang isinasagawa ang iteration, madaling magkaroon ng loop na hindi natatapos. Isang napaka-kapaki-pakinabang na pamamaraan ang pag-ulit sa isang kopya ng orihinal na koleksyon, na ginagawa ang mga kinakailangang pagbabago sa "totoong" bersyon.

Tungkol naman sa pangkalahatang pinakamahusay na kasanayan, karaniwang ipinapayong gamitin ForEach-Object para sa datos na dumarating sa pamamagitan ng pipeline, pinapanatiling madaling basahin ang katawan ng loop hangga't maaari gamit ang mga auxiliary function, at naglalapat ng pare-parehong indentation at mga komento upang mapadali ang pagpapanatili ng script sa paglipas ng panahon.

Pag-master sa iba't ibang foreach variant at sa kanilang mga opsyon sa parallelism sa PowerShell, mula sa ForEach-Object -Parallel y Start-ThreadJob kahit ang mga sinaunang tao foreach -Parallel Sa Workflows, pinapayagan ka nito magdisenyo ng mas mabilis at mas matatag na mga script, pagpili sa bawat kaso kung interesado kang unahin ang performance, memory, output order o code simplicity, sa halip na laging limitahan ang iyong sarili sa tradisyonal na sequential loop.