ForEach-Object

Modul:

Microsoft.PowerShell.Core

Műveletet hajt végre a bemeneti objektumok gyűjteményének egyes elemein.

Syntax

ForEach-Object
            [-InputObject <PSObject>]
            [-Begin <ScriptBlock>]
            [-Process] <ScriptBlock[]>
            [-End <ScriptBlock>]
            [-RemainingScripts <ScriptBlock[]>]
            [-WhatIf]
            [-Confirm]
            [<CommonParameters>]

ForEach-Object
            [-InputObject <PSObject>]
            [-MemberName] <String>
            [-ArgumentList <Object[]>]
            [-WhatIf]
            [-Confirm]
            [<CommonParameters>]

ForEach-Object
            -Parallel <scriptblock>
            [-InputObject <psobject>]
            [-ThrottleLimit <int>]
            [-TimeoutSeconds <int>]
            [-AsJob]
            [-UseNewRunspace]
            [-WhatIf]
            [-Confirm]
            [<CommonParameters>]

Description

A ForEach-Object parancsmag egy bemeneti objektumgyűjtemény minden elemén végrehajt egy műveletet. A bemeneti objektumok a parancsmagba csövezhetők, vagy az InputObject paraméterrel adhatók meg.

A Windows PowerShell 3.0-tól kezdve két különböző módon hozhat létre parancsokat ForEach-Object .

• Szkriptblokk. A művelet megadásához szkriptblokkot használhat. A szkriptblokkon belül használja a változót $_ az aktuális objektum megjelenítéséhez. A szkriptblokk a Folyamat paraméter értéke. A szkriptblokk bármilyen PowerShell-szkriptet tartalmazhat.

  A következő parancs például lekéri a számítógépen található egyes folyamatok ProcessName tulajdonságának értékét.

  Get-Process | ForEach-Object {$_.ProcessName}

  ForEach-Objecttámogatja a begin, processés end blokkokat az about_functions.

  Feljegyzés

  A szkriptblokkok a hívó hatókörében futnak. Ezért a blokkok hozzáféréssel rendelkeznek a hatókör változóihoz, és új változókat hozhatnak létre, amelyek a parancsmag befejeződése után is megmaradnak a hatókörben.

• Műveleti utasítás. Egy műveleti utasítást is írhat, amely sokkal inkább hasonlít a természetes nyelvhez. A műveleti utasítással megadhat egy tulajdonságértéket, vagy meghívhat egy metódust. A műveleti utasítások a Windows PowerShell 3.0-ban lettek bevezetve.

  A következő parancs például a számítógépen található egyes folyamatok ProcessName tulajdonságának értékét is lekéri.

  Get-Process | ForEach-Object ProcessName

• Párhuzamos futó szkriptblokk. A PowerShell 7.0-tól kezdve egy harmadik paraméterkészlet érhető el, amely az egyes szkriptblokkokat párhuzamosan futtatja. A ThrottleLimit paraméter korlátozza az egyszerre futó párhuzamos szkriptek számát. Mint korábban, a $_ változóval a szkriptblokk aktuális bemeneti objektumát jelölheti. $using: A kulcsszóval változóhivatkozásokat adhat át a futó szkriptnek.

  A PowerShell 7-ben minden ciklus iterációjához új futtatótér jön létre a maximális elkülönítés biztosítása érdekében. Ez nagy teljesítmény- és erőforrás-találat lehet, ha a végzett munka kicsi az új futtatóterek létrehozásához képest, vagy ha sok iteráció végez jelentős munkát. A PowerShell 7.1-től kezdve a rendszer alapértelmezés szerint újra felhasználja a runspace-készletből származó runspace-eket. A ThrottleLimit paraméter beállítja a futtatótérkészlet méretét. Az alapértelmezett futtatótérkészlet mérete 5. A UseNewRunspace kapcsolóval továbbra is létrehozhat egy új futtatóteret minden iterációhoz.

  Alapértelmezés szerint a párhuzamos szkriptblokkok a párhuzamos feladatokat kezdeményező hívó aktuális munkakönyvtárát használják.

  További információkért tekintse meg a cikk NOTES szakaszát.

Példák

1. példa: Egész számok osztása tömbben

Ez a példa három egész számból álló tömböt vesz fel, és mindegyiket 1024-sel osztja el.

30000, 56798, 12432 | ForEach-Object -Process {$_/1024}

29.296875
55.466796875
12.140625

2. példa: A könyvtárban lévő összes fájl hosszának lekérése

Ez a példa a PowerShell telepítési könyvtárában $PSHOMElévő fájlokat és könyvtárakat dolgozza fel.

Get-ChildItem $PSHOME |
  ForEach-Object -Process {if (!$_.PSIsContainer) {$_.Name; $_.Length / 1024; " " }}

Ha az objektum nem könyvtár, a szkriptblokk lekéri a fájl nevét, 1024-tel osztja el a Hossz tulajdonság értékét, és hozzáad egy szóközt (" ") a következő bejegyzéstől való elválasztásához. A parancsmag a PSISContainer tulajdonsággal határozza meg, hogy egy objektum könyvtár-e.

3. példa: A legutóbbi rendszeresemények üzemeltetése

Ez a példa a Rendszer eseménynaplójának 1000 legutóbbi eseményét írja egy szövegfájlba. Az aktuális idő az események feldolgozása előtt és után jelenik meg.

Get-EventLog -LogName System -Newest 1000 |
    ForEach-Object -Begin {Get-Date} -Process {
        Out-File -FilePath Events.txt -Append -InputObject $_.Message
    } -End {Get-Date}

Get-EventLog lekéri az 1000 legutóbbi eseményt a rendszer eseménynaplójából, és a parancsmagba csövezi őket ForEach-Object . A Begin paraméter megjeleníti az aktuális dátumot és időpontot. Ezután a Folyamat paraméter a Out-File parancsmaggal hoz létre egy events.txt nevű szövegfájlt, és tárolja az egyes események üzenettulajdonságait a fájlban. Végül a Vég paraméter a feldolgozás befejezése utáni dátumot és időt jeleníti meg.

4. példa: Beállításkulcs értékének módosítása

Ez a példa a RemotePath beállításjegyzék-bejegyzés értékét a kulcs alatti HKCU:\Network összes alkulcsban nagybetűs szövegre módosítja.

Get-ItemProperty -Path HKCU:\Network\* |
  ForEach-Object {
    Set-ItemProperty -Path $_.PSPath -Name RemotePath -Value $_.RemotePath.ToUpper()
  }

Ezzel a formátummal módosíthatja egy beállításjegyzék-bejegyzés értékének űrlapját vagy tartalmát.

A Hálózati kulcs minden alkulcsa egy leképezett hálózati meghajtót jelöl, amely a bejelentkezéskor újracsatlakozik. A RemotePath bejegyzés a csatlakoztatott meghajtó UNC elérési útját tartalmazza. Ha például leképezi a E: meghajtót \\Server\Share, egy E alkulcs jön létre HKCU:\Network a RemotePath beállításjegyzékének értékeként \\Server\Share.

A parancs a Get-ItemProperty parancsmaggal lekéri a Hálózati kulcs és a Set-ItemProperty parancsmag összes alkulcsát, hogy az egyes kulcsokban módosítsa a RemotePath beállításjegyzék-bejegyzésének értékét. Set-ItemProperty A parancsban az elérési út a beállításkulcs PSPath tulajdonságának értéke. Ez a Microsoft .NET-keretrendszer objektum tulajdonsága, amely a beállításkulcsot jelöli, nem pedig a beállításjegyzék-bejegyzést. A parancs a RemotePath érték ToUpper() metódusát használja, amely egy sztring REG_SZ.

Mivel Set-ItemProperty az egyes kulcsok tulajdonságát módosítja, a ForEach-Object parancsmagnak hozzá kell férnie a tulajdonsághoz.

5. példa: Az $null automatikus változó használata

Ez a példa azt mutatja be, hogy milyen hatással van az $null automatikus változó a ForEach-Object parancsmagra.

1, 2, $null, 4 | ForEach-Object {"Hello"}

Hello
Hello
Hello
Hello

Mivel a PowerShell explicit helyőrzőként kezeli $null , a ForEach-Object parancsmag olyan értéket $null hoz létre, mint a más, rá irányuló objektumok esetében.

6. példa: Tulajdonságértékek lekérése

Ez a példa a parancsmag MemberName paraméterével lekéri az összes telepített PowerShell-modul Path tulajdonságának ForEach-Object értékét.

Get-Module -ListAvailable | ForEach-Object -MemberName Path
Get-Module -ListAvailable | Foreach Path

A második parancs egyenértékű az első paranccsal. A parancsmag aliasát ForEach-Object használjaForeach, és kihagyja a MemberName paraméter nevét, ami nem kötelező.

A ForEach-Object parancsmag a tulajdonságértékek lekéréséhez hasznos, mert a típus módosítása nélkül kapja meg az értéket, ellentétben a Formátum parancsmagokkal vagy a Select-Object tulajdonság értéktípusát módosító parancsmaggal.

7. példa: Modulnevek felosztása összetevőnevekre

Ebben a példában háromféleképpen oszthat fel két pontból álló modulnevet az összetevők neveire. A parancsok meghívják a sztringek felosztási metódusát. A három parancs különböző szintaxist használ, de egyenértékűek és felcserélhetők. A kimenet mindhárom esetben ugyanaz.

"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" |
    ForEach-Object {$_.Split(".")}
"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" |
    ForEach-Object -MemberName Split -ArgumentList "."
"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" |
    Foreach Split "."

Microsoft
PowerShell
Core
Microsoft
PowerShell
Host

Az első parancs a hagyományos szintaxist használja, amely egy szkriptblokkot és az aktuális objektumoperátort $_tartalmazza. A pontszintaxis használatával adja meg a metódust és zárójeleket az elválasztó argumentum beágyazásához.

A második parancs a MemberName paramétert használja a felosztási metódus és az Argumentumlista paraméter megadására a pont (.) felosztási elválasztóként való azonosításához.

A harmadik parancs a parancsmag Foreach aliasát ForEach-Object használja, és kihagyja a MemberName és az ArgumentList paraméterek nevét, amelyek nem kötelezőek.

8. példa: ForEach-Object használata két szkriptblokkdal

Ebben a példában két szkriptblokkot adunk át pozícióban. Az összes szkriptblokk a Folyamat paraméterhez kapcsolódik. A művelet azonban úgy kezeli őket, mintha át lettek volna adva a Begin és a Process paramétereknek.

1..2 | ForEach-Object { 'begin' } { 'process' }

begin
process
process

9. példa: A ForEach-Object használata kétnál több szkriptblokkdal

Ebben a példában négy szkriptblokkot adunk át pozícióban. Az összes szkriptblokk a Folyamat paraméterhez kapcsolódik. A művelet azonban úgy kezeli őket, mintha át lettek volna adva a Begin, a Process és a End paraméternek.

1..2 | ForEach-Object { 'begin' } { 'process A' }  { 'process B' } { 'end' }

begin
process A
process B
process A
process B
end

Feljegyzés

Az első szkriptblokk mindig a begin blokkhoz van leképezve, az utolsó blokk a blokkhoz end van leképezve, a két középső blokk pedig a process blokkhoz van leképezve.

10. példa: Több szkriptblokk futtatása minden folyamatelemhez

Ahogy az előző példában is látható, a Folyamat paraméterrel átadott szkriptblokkok leképezhetők a Begin és a End paraméterekre. A leképezés elkerülése érdekében explicit értékeket kell megadnia a Kezdő és a Záró paraméterhez.

1..2 | ForEach-Object -Begin $null -Process { 'one' }, { 'two' }, { 'three' } -End $null

one
two
three
one
two
three

11. példa: Lassú szkript futtatása párhuzamos kötegekben

Ez a példa egy szkriptblokkot futtat, amely kiértékel egy sztringet, és egy másodpercig alszik.

$Message = "Output:"

1..8 | ForEach-Object -Parallel {
    "$using:Message $_"
    Start-Sleep 1
} -ThrottleLimit 4

Output: 1
Output: 2
Output: 3
Output: 4
Output: 5
Output: 6
Output: 7
Output: 8

A ThrottleLimit paraméter értéke 4, így a bemenet négy kötegben lesz feldolgozva. A $using: kulcsszó a változónak az $Message egyes párhuzamos szkriptblokkokba való átadására szolgál.

12. példa: Naplóbejegyzések lekérése párhuzamosan

Ez a példa 50 000 naplóbejegyzést kér le 5 rendszernaplóból egy helyi Windows-gépen.

$logNames = 'Security', 'Application', 'System', 'Windows PowerShell',
    'Microsoft-Windows-Store/Operational'

$logEntries = $logNames | ForEach-Object -Parallel {
    Get-WinEvent -LogName $_ -MaxEvents 10000
} -ThrottleLimit 5

$logEntries.Count

50000

A Párhuzamos paraméter az egyes bemeneti naplónevekhez párhuzamosan futó szkriptblokkot adja meg. A ThrottleLimit paraméter biztosítja, hogy mind az öt szkriptblokk egyszerre fusson.

13. példa: Párhuzamos futtatás feladatként

Ez a példa egy olyan feladatot hoz létre, amely párhuzamosan futtat egy szkriptblokkot, egyszerre kettővel.

PS> $job = 1..10 | ForEach-Object -Parallel {
    "Output: $_"
    Start-Sleep 1
} -ThrottleLimit 2 -AsJob

PS> $job

Id     Name            PSJobTypeName   State         HasMoreData     Location      Command
--     ----            -------------   -----         -----------     --------      -------
23     Job23           PSTaskJob       Running       True            PowerShell    …

PS> $job.ChildJobs

Id     Name            PSJobTypeName   State         HasMoreData     Location      Command
--     ----            -------------   -----         -----------     --------      -------
24     Job24           PSTaskChildJob  Completed     True            PowerShell    …
25     Job25           PSTaskChildJob  Completed     True            PowerShell    …
26     Job26           PSTaskChildJob  Running       True            PowerShell    …
27     Job27           PSTaskChildJob  Running       True            PowerShell    …
28     Job28           PSTaskChildJob  NotStarted    False           PowerShell    …
29     Job29           PSTaskChildJob  NotStarted    False           PowerShell    …
30     Job30           PSTaskChildJob  NotStarted    False           PowerShell    …
31     Job31           PSTaskChildJob  NotStarted    False           PowerShell    …
32     Job32           PSTaskChildJob  NotStarted    False           PowerShell    …
33     Job33           PSTaskChildJob  NotStarted    False           PowerShell    …

A ThrottleLimit paraméter korlátozza az egyszerre futó párhuzamos szkriptblokkok számát. Az AsJob paraméter hatására a parancsmag feladatobjektumot ForEach-Object ad vissza ahelyett, hogy a kimenetet a konzolra streameli. A $job változó megkapja a kimeneti adatokat gyűjtő feladatobjektumot, és figyeli a futó állapotot. A $job.ChildJobs tulajdonság tartalmazza a párhuzamos szkriptblokkokat futtató gyermekfeladatokat.

14. példa: Szálbiztos változóhivatkozások használata

Ez a példa szkriptblokkokat hív meg párhuzamosan az egyedileg elnevezett folyamatobjektumok gyűjtéséhez.

$threadSafeDictionary = [System.Collections.Concurrent.ConcurrentDictionary[string,object]]::new()
Get-Process | ForEach-Object -Parallel {
    $dict = $using:threadSafeDictionary
    $dict.TryAdd($_.ProcessName, $_)
}

$threadSafeDictionary["pwsh"]

NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
     82    82.87     130.85      15.55    2808   2 pwsh

A concurrentDictionary objektum egyetlen példánya kerül minden szkriptblokkba az objektumok gyűjtéséhez. Mivel a ConcurrentDictionary szálbiztos, minden párhuzamos szkript biztonságosan módosítható. Egy nem szálbiztos objektum, például a System.Collections.Generic.Dictionary nem lenne biztonságos itt.

Feljegyzés

Ez a példa a Párhuzamos paraméter nem hatékony használatát szemlélteti. A szkript hozzáadja a bemeneti objektumot egy egyidejű szótárobjektumhoz. Ez triviális, és nem éri meg az egyes szkriptek meghívásának többletterhelését egy külön szálon. A Párhuzamos kapcsoló nélkül történő futtatás ForEach-Object hatékonyabb és gyorsabb. Ez a példa csak a szálbiztos változók használatát mutatja be.

15. példa: Hibák írása párhuzamos végrehajtással

Ez a példa párhuzamosan ír a hibafolyamba, ahol az írott hibák sorrendje véletlenszerű.

1..3 | ForEach-Object -Parallel {
    Write-Error "Error: $_"
}

Write-Error: Error: 1
Write-Error: Error: 3
Write-Error: Error: 2

16. példa: A párhuzamos végrehajtás során felmerülő hibák megszüntetése

Ez a példa azt mutatja be, hogy egy párhuzamos szkriptblokkban végződő hiba lépett fel.

1..5 | ForEach-Object -Parallel {
    if ($_ -eq 3)
    {
        throw "Terminating Error: $_"
    }

    Write-Output "Output: $_"
}

Exception: Terminating Error: 3
Output: 1
Output: 4
Output: 2
Output: 5

Output: 3 soha nem íródott, mert az iteráció párhuzamos szkriptblokkja leállt.

Feljegyzés

A PipelineVariable gyakori paraméterváltozók még a kulcsszóval sem támogatottak Foreach-Object -Parallel a $using: forgatókönyvekben.

17. példa: Változók átadása beágyazott párhuzamos szkriptben ScriptBlockSet

Létrehozhat egy változót egy Foreach-Object -Parallel hatókörrel rendelkező szkriptblokkon kívül, és használhatja azt a szkriptblokkban a $using kulcsszóval együtt.

$test1 = 'TestA'
1..2 | Foreach-Object -Parallel {
    $using:test1
}

TestA
TestA

# You CANNOT create a variable inside a scoped scriptblock
# to be used in a nested foreach parallel scriptblock.
$test1 = 'TestA'
1..2 | Foreach-Object -Parallel {
    $using:test1
    $test2 = 'TestB'
    1..2 | Foreach-Object -Parallel {
        $using:test2
    }
}

Line |
   2 |  1..2 | Foreach-Object -Parallel {
     |         ~~~~~~~~~~~~~~~~~~~~~~~~~~
     | The value of the using variable '$using:test2' can't be retrieved because it has
     | not been set in the local session.

A beágyazott szkriptblokk nem fér hozzá a $test2 változóhoz, és hibaüzenet jelenik meg.

18. példa: Több, szkripteket párhuzamosan futtató feladat létrehozása

A ThrottleLimit paraméter korlátozza az egyes példányok ForEach-Object -Parallelsorán futó párhuzamos szkriptek számát. Nem korlátozza az AsJob paraméter használatakor létrehozható feladatok számát. Mivel maguk a feladatok párhuzamosan futnak, több párhuzamos feladat is létrehozható, amelyek mindegyike az egyidejű szkriptblokkok megengedett korlátjához ér.

$jobs = for ($i=0; $i -lt 10; $i++) {
    1..10 | ForEach-Object -Parallel {
        ./RunMyScript.ps1
    } -AsJob -ThrottleLimit 5
}

$jobs | Receive-Job -Wait

Ez a példa 10 futó feladatot hoz létre. Minden feladat nem futtat egyszerre több 5 szkriptet. Az egyidejűleg futó példányok teljes száma 50-re korlátozódik (10 feladat az 5 ThrottleLimit értékének 10-szerese).

Paraméterek

-ArgumentList

Egy metódushívás argumentumainak tömbje. Az Argumentumlista működésével kapcsolatos további információkért lásd: about_Splatting.

Ezt a paramétert a Windows PowerShell 3.0-ban vezettük be.

Típus:	Object[]
Aliasok:	Args
Position:	Named
Alapértelmezett érték:	None
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-AsJob

A párhuzamos meghívás PowerShell-feladatként való futtatását okozza. A rendszer egyetlen feladatobjektumot ad vissza a futó szkriptblokkok kimenete helyett. A feladatobjektum gyermekfeladatokat tartalmaz minden futtatott párhuzamos szkriptblokkhoz. A feladatobjektumot bármelyik PowerShell-feladatparancsmaggal használhatja a futó állapot megtekintéséhez és az adatok lekéréséhez.

Ezt a paramétert a PowerShell 7.0-ban vezettük be.

Típus:	SwitchParameter
Position:	Named
Alapértelmezett érték:	None
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-Begin

Olyan szkriptblokkot ad meg, amely azelőtt fut, hogy ez a parancsmag feldolgozza a bemeneti objektumokat. Ez a szkriptblokk csak egyszer fut a teljes folyamathoz. További információ a begin blokkról: about_Functions.

Típus:	ScriptBlock
Position:	Named
Alapértelmezett érték:	None
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-Confirm

Jóváhagyást kér a parancsmag futtatása előtt.

Típus:	SwitchParameter
Aliasok:	cf
Position:	Named
Alapértelmezett érték:	False
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-End

Egy szkriptblokkot ad meg, amely azután fut, hogy ez a parancsmag feldolgozza az összes bemeneti objektumot. Ez a szkriptblokk csak egyszer fut a teljes folyamathoz. További információ a end blokkról: about_Functions.

Típus:	ScriptBlock
Position:	Named
Alapértelmezett érték:	None
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-InputObject

Megadja a bemeneti objektumokat. ForEach-Object Minden bemeneti objektumon futtatja a szkriptblokkot vagy a műveleti utasítást. Adjon meg egy változót, amely tartalmazza az objektumokat, vagy írjon be egy parancsot vagy kifejezést, amely lekéri az objektumokat.

Ha az InputObject paramétert ForEach-Objecthasználja a piping parancs eredményei ForEach-Objecthelyett, a rendszer egyetlen objektumként kezeli az InputObject értéket. Ez akkor is igaz, ha az érték egy parancs eredménye, például -InputObject (Get-Process). Mivel az InputObject nem tud egyedi tulajdonságokat visszaadni egy tömbből vagy objektumgyűjteményből, javasoljuk, hogy ha olyan objektumok gyűjteményén hajt ForEach-Object végre műveleteket, amelyek meghatározott tulajdonságokban meghatározott értékekkel rendelkeznek, akkor ForEach-Object használja a folyamatban a jelen témakör példáiban látható módon.

Típus:	PSObject
Position:	Named
Alapértelmezett érték:	None
Kötelező:	False
Folyamatbemenet elfogadása:	True
Helyettesítő karakterek elfogadása:	False

-MemberName

Megadja a lekérni kívánt tagtulajdonság nevét vagy a meghívni kívánt tagmetódus nevét. A tagoknak példánytagnak kell lenniük, nem statikus tagoknak.

A helyettesítő karakterek használata engedélyezett, de csak akkor működik, ha az eredményül kapott sztring egyedi értékre van feloldva. Ha például futtatja Get-Process | ForEach -MemberName *Name, a helyettesítő karakterminta egynél több tagra egyezik, ami miatt a parancs meghiúsul.

Ezt a paramétert a Windows PowerShell 3.0-ban vezettük be.

Típus:	String
Position:	0
Alapértelmezett érték:	None
Kötelező:	True
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	True

-Parallel

Megadja a bemeneti objektumok párhuzamos feldolgozásához használandó szkriptblokkot. Adjon meg egy szkriptblokkot, amely leírja a műveletet.

Ezt a paramétert a PowerShell 7.0-ban vezettük be.

Típus:	ScriptBlock
Position:	Named
Alapértelmezett érték:	None
Kötelező:	True
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-Process

Meghatározza az egyes bemeneti objektumokon végrehajtott műveletet. Ez a szkriptblokk a folyamat minden objektumához fut. További információ a process blokkról: about_Functions.

Ha több szkriptblokkot ad meg a Folyamat paraméternek, az első szkriptblokk mindig a begin blokkhoz lesz leképezve. Ha csak két szkriptblokk van, a második blokk a blokkhoz process van leképezve. Ha három vagy több szkriptblokk van, az első szkriptblokk mindig a begin blokkra van leképezve, az utolsó blokk a blokkra end van leképezve, a középső blokkok pedig a process blokkra vannak leképezve.

Típus:	ScriptBlock[]
Position:	0
Alapértelmezett érték:	None
Kötelező:	True
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-RemainingScripts

Megadja az összes olyan szkriptblokkot, amelyet a Folyamat paraméter nem vesz fel.

Ezt a paramétert a Windows PowerShell 3.0-ban vezettük be.

Típus:	ScriptBlock[]
Position:	Named
Alapértelmezett érték:	None
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-ThrottleLimit

A párhuzamosan futó szkriptblokkok számát adja meg. A bemeneti objektumok mindaddig le lesznek tiltva, amíg a futó szkriptblokkok száma a ThrottleLimit alá nem csökken. Az alapértelmezett érték 5.

A ThrottleLimit paraméter korlátozza az egyes példányok ForEach-Object -Parallelsorán futó párhuzamos szkriptek számát. Nem korlátozza az AsJob paraméter használatakor létrehozható feladatok számát. Mivel maguk a feladatok párhuzamosan futnak, több párhuzamos feladat is létrehozható, amelyek mindegyike az egyidejű szkriptblokkok megengedett korlátjához ér.

Ezt a paramétert a PowerShell 7.0-ban vezettük be.

Típus:	Int32
Position:	Named
Alapértelmezett érték:	5
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-TimeoutSeconds

Megadja, hogy hány másodpercig kell várni az összes bemenet párhuzamos feldolgozására. A megadott időtúllépési idő után az összes futó szkript le lesz állítva. A többi feldolgozandó bemeneti objektumot pedig figyelmen kívül hagyja a rendszer. Az alapértelmezett érték 0 letiltja az időtúllépést, és ForEach-Object -Parallel határozatlan ideig futtatható. A Ctrl+C parancssorba való beírása leállítja a futó ForEach-Object -Parallel parancsokat. Ez a paraméter nem használható az AsJob paraméterrel együtt.

Ezt a paramétert a PowerShell 7.0-ban vezettük be.

Típus:	Int32
Position:	Named
Alapértelmezett érték:	0
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-UseNewRunspace

A párhuzamos meghívás minden ciklus iterációjához létrehoz egy új futtatóteret ahelyett, hogy újrahasználja a runspace-készletből származó runspace-eket.

Ez a paraméter a PowerShell 7.1-ben lett bevezetve

Típus:	SwitchParameter
Position:	Named
Alapértelmezett érték:	False
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

-WhatIf

Bemutatja, mi történne a parancsmag futtatásakor. A parancsmag nem fut.

Típus:	SwitchParameter
Aliasok:	wi
Position:	Named
Alapértelmezett érték:	False
Kötelező:	False
Folyamatbemenet elfogadása:	False
Helyettesítő karakterek elfogadása:	False

Bevitelek

PSObject

A parancsmaghoz bármilyen objektumot csövezhet.

Kimenetek

PSObject

Ez a parancsmag a bemenet által meghatározott objektumokat adja vissza.

Jegyzetek

A PowerShell a következő aliasokat ForEach-Objecttartalmazza:

• Minden platform:
  • %
  • foreach

A ForEach-Object parancsmag a Foreach utasításhoz hasonlóan működik, azzal a kivétellel, hogy a Foreach utasításhoz nem lehet bemenő csövet adni. A Foreach-utasítással kapcsolatos további információkért lásd: about_Foreach.

A PowerShell 4.0-tól Where ForEach kezdve a gyűjteményekhez használható metódusok lettek hozzáadva. Ezekről az új módszerekről itt olvashat bővebben about_arrays

A következő használatával ForEach-Object -Parallel:

• ForEach-Object -Parallel az egyes szkriptblokkokat egy új futtatótérben futtatja. Az új futtatóterek jelentősen nagyobb többletterhelést okoznak, mint a szekvenciális feldolgozással való futtatás ForEach-Object . Fontos a Párhuzamos használata, ahol a párhuzamos futtatás többletterhelése kicsi a szkriptblokk által végzett munkához képest. Példa:

  • Számítási igényű szkriptek többmagos gépeken
  • Az eredményekre való várakozást vagy fájlműveleteket végző szkriptek

  A Párhuzamos paraméter használata esetén a szkriptek a szokásosnál sokkal lassabban futnak. Különösen akkor, ha a párhuzamos szkriptek triviálisak. Kísérletezzen a Parallelnel, hogy kiderítse, hol lehet hasznos.

• Ha párhuzamosan fut, a ScriptProperties vagy a ScriptMethods által dekorált objektumok nem garantálhatók a helyes működésre, ha más futtató térben futnak, mint a szkriptek eredetileg hozzájuk voltak csatolva.

  A szkriptblokk meghívása mindig a saját futtatókörnyezetében próbál futni, függetlenül attól, hogy hol hívja meg a rendszer. Azonban ideiglenes runspace-eket hoz létre, ForEach-Object -Parallel amelyek használat után törlődnek, így a szkriptek már nem futtathatók.

  Ez a viselkedés mindaddig működik, amíg az otthoni futtatótér még létezik. Előfordulhat azonban, hogy nem kapja meg a kívánt eredményt, ha a szkript olyan külső változóktól függ, amelyek csak a hívó futtatóterében találhatók, és nem a kezdő futtatótérben.

• A nem végződő hibák a parancsmag hibastreambe lesznek írva, miközben párhuzamosan futó szkriptblokkokban fordulnak elő. Mivel a párhuzamos szkriptblokk végrehajtási sorrendje nem determinisztikus, a hibák a hibastreamben való megjelenésének sorrendje véletlenszerű. Hasonlóképpen, a más adatfolyamokra, például figyelmeztetésre, részletesre vagy információkra írt üzeneteket a rendszer határozatlan sorrendben írja az adatfolyamokra.

  A hibák( például kivételek) megszüntetése leállítja azoknak a szkriptblokkoknak az egyéni párhuzamos példányát, amelyekben ezek előfordulnak. Előfordulhat, hogy egy szkriptblokkban megszűnő hiba nem okozza a Foreach-Object parancsmag leállítását. A többi, párhuzamosan futó szkriptblokk továbbra is fut, kivéve, ha végződési hibába ütköznek. A megszüntető hiba a hibaadat-adatfolyamba lesz beírva errorRecord for a FullyQualifiedErrorId of PSTaskException. A megszüntetési hibák PowerShell-lel trycatch/vagy trap blokkokkal nem végződő hibákká alakíthatók.

• A PipelineVariable gyakori paraméterváltozók nem támogatottak párhuzamos forgatókönyvekben még a $using: kulcsszóval sem.

  Fontos

  A ForEach-Object -Parallel paraméterkészlet szkriptblokkokat futtat párhuzamosan külön folyamatszálakon. A $using: kulcsszó lehetővé teszi változóhivatkozások átadását a parancsmag meghívási száláról minden futó szkriptblokk-szálra. Mivel a szkriptblokkok különböző szálakban futnak, a hivatkozás által átadott objektumváltozókat biztonságosan kell használni. Általában biztonságos az olyan hivatkozott objektumokból olvasni, amelyek nem változnak. Ha módosítania kell az objektum állapotát, akkor szálbiztos objektumokat kell használnia, például .NET System.Collection.Concurrent típusokat (lásd a 14. példát).

Kapcsolódó hivatkozások

• Compare-Object
• Where-Object
• Group-Object
• Measure-Object
• New-Object
• Select-Object
• Sort-Object
• Tee-Object