ForEach-Object

Sintassi

ForEach-Object <ScriptBlock> >] 

ForEach-Object <String> >] 

ForEach-Object -Parallel <scriptblock> 

Descrizione

La ForEach-Object cmdlet esegue un’operazione su ogni elemento di una collezione di oggetti di input. Gli oggetti di input possono essere inviati alla cmdlet o specificati usando il parametro InputObject.

A partire da Windows PowerShell 3.0, ci sono due modi diversi per costruire un ForEach-Objectcomando.

• Blocco di script. Puoi usare un blocco di script per specificare l’operazione. All’interno del blocco di script, usate la variabile $_ per rappresentare l’oggetto corrente. Il blocco di script è il valore del parametroProcess. Il blocco di script può contenere qualsiasi script PowerShell.

  Per esempio, il seguente comando ottiene il valore della proprietà ProcessName di ogni processo sul computer.

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

  ForEach-Object supporta il beginprocess, e end blocchi come descritto inabout_functions.

  Nota

  I blocchi di script vengono eseguiti nell’ambito del chiamante. Perciò i blocchi hanno accesso alle variabili in quell’ambito e possono creare nuove variabili che persistono in quell’ambito dopo il completamento del cmdlet.

• Dichiarazione di operazione. Puoi anche scrivere un’istruzione di operazione, che è molto più simile al linguaggio naturale. Puoi usare l’istruzione di operazione per specificare il valore di una proprietà o chiamare un metodo. Le istruzioni di operazione sono state introdotte in Windows PowerShell 3.0.

  Per esempio, il seguente comando ottiene anche il valore della proprietà ProcessName di ogni processo sul computer.

  Get-Process | ForEach-Object ProcessName

• Blocco script a esecuzione parallela. A partire da PowerShell 7.0, è disponibile un terzo set di parametri che esegue ogni blocco di script in parallelo. Il parametro ThrottleLimit limita il numero di script in esecuzione parallela alla volta. Come prima, usa la variabile $_ per rappresentare l’oggetto di input corrente nel blocco di script. Usare la parola chiave $using: per passare i riferimenti variabili allo script in esecuzione.

  In PowerShell 7, viene creato un nuovo runspace per ogni iterazione del ciclo per garantire il massimo isolamento.Questo può essere un grande impatto sulle prestazioni e sulle risorse se il lavoro che si sta facendo è piccolo rispetto alla creazione di nuovi runspace o se ci sono molte iterazioni che eseguono un lavoro significativo. A partire da PowerShell 7.1, i runspace di un pool di runspace vengono riutilizzati per default. La dimensione del pool di runspace è specificata dal parametro ThrottleLimit. La dimensione predefinita del pool di runspace è 5. Puoi comunque creare un nuovo runspace per ogni iterazione usando l’interruttore UseNewRunspace.

  Per impostazione predefinita, i blocchi di script paralleli utilizzano la directory di lavoro corrente del chiamante che ha avviato i task paralleli.

  Gli errori che non terminano vengono scritti nel flusso di errore del cmdlet quando si verificano nei blocchi di script in esecuzione parallela. Poiché l’ordine di esecuzione dei blocchi di script in parallelo non può essere determinato, l’ordine in cui gli errori appaiono nel flusso degli errori è casuale. Allo stesso modo, i messaggi scritti in altri flussi di dati, come warning, verbose, o information sono scritti in quei flussi di dati in un ordine indeterminato.

  Gli errori terminanti, come le eccezioni, terminano la singola istanza parallela degli scriptblock in cui si verificano. Un errore di terminazione in uno scriptblock può non causare la terminazione del Foreach-Object cmdlet. Gli altri blocchi di script, eseguiti in parallelo, continuano a funzionare a meno che non incontrino anch’essi un errore di terminazione. L’errore terminante viene scritto nel flusso di dati degli errori come un ErrorRecord con un FullyQualifiedErrorId di PSTaskException. Gli errori terminanti possono essere convertiti in errori non terminanti usando PowerShell try/catch o trapblocks.

Esempi

Esempio 1: Dividere interi in un array

Questo esempio prende un array di tre interi e divide ciascuno di essi per 1024.

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

Esempio 2: Ottenere la lunghezza di tutti i file in una directory

Questo esempio processa i file e le directory nella directory di installazione di PowerShell $PSHOME.

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

Se l’oggetto non è una directory, il blocco di script ottiene il nome del file, divide il valore della sua proprietà Length per 1024, e aggiunge uno spazio (” “) per separarlo dalla voce successiva. Il comando usa la proprietà PSISContainer per determinare se un oggetto è una directory.

Esempio 3: Operare sugli eventi di sistema più recenti

Questo esempio scrive i 1000 eventi più recenti dal registro eventi di sistema in un file di testo. L’ora corrente viene visualizzata prima e dopo l’elaborazione degli eventi.

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

Get-EventLog ottiene i 1000 eventi più recenti dal registro eventi di sistema e li memorizza nella variabile$Events$Events viene poi convogliato al ForEach-Object cmdlet. Il parametro Begin mostra la data e l’ora attuali. Successivamente, il parametro Process utilizza il cmdlet Out-File per creare un file di testo chiamato events.txt e memorizza la proprietà del messaggio di ogni evento in questo file. Infine, il parametro End è usato per visualizzare la data e l’ora dopo che tutta l’elaborazione è stata completata.

Esempio 4: Cambiare il valore di una chiave di registro

Questo esempio cambia il valore della voce di registro RemotePath in tutte le sottochiavi sotto la chiaveHKCU:\Network in testo maiuscolo.

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

Puoi usare questo formato per cambiare la forma o il contenuto del valore di una voce di registro.

Ogni sottochiave nella chiave Network rappresenta un’unità di rete mappata che si ricollega all’accesso. La voceRemotePath contiene il percorso UNC dell’unità collegata. Per esempio, se si mappa l’unità E:a \\Server\Share, una sottochiave E viene creata in HKCU:\Network con il valore RemotePathregistry impostato a \\Server\Share.

Il comando usa la cmdlet Get-ItemProperty per ottenere tutte le sottochiavi della chiave Network e la cmdlet Set-ItemProperty per cambiare il valore della voce di registro RemotePath in ogni chiave.Nel comando Set-ItemProperty, il percorso è il valore della proprietà PSPath della chiave di registro. Questa è una proprietà dell’oggetto Microsoft .NET Framework che rappresenta la chiave di registro, non la voce di registro. Il comando usa il metodo ToUpper() del valore RemotePath, che è una stringa (REG_SZ).

Perché Set-ItemProperty sta cambiando la proprietà di ogni chiave, il ForEach-Object cmdlet è necessario per accedere alla proprietà.

Esempio 5: Utilizzare la variabile automatica $Null

Questo esempio mostra l’effetto del piping della variabile automatica $Null alla ForEach-Objectcmdlet.

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

Perché PowerShell tratta null come un segnaposto esplicito, la ForEach-Object cmdlet genera un valore per $Null, proprio come fa per altri oggetti che le vengono inviati tramite pipe.

Esempio 6: Ottenere i valori delle proprietà

Questo esempio ottiene il valore della proprietà Path di tutti i moduli PowerShell installati utilizzando il parametro MemberName del ForEach-Object cmdlet.

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

Il secondo comando è equivalente al primo. Usa l’alias Foreach dell’ForEach-Objectcmdlet e omette il nome del parametro MemberName, che è opzionale.

Il cmdlet ForEach-Object è utile per ottenere valori di proprietà, perché ottiene il valore senza cambiarne il tipo, a differenza dei cmdlet Format o del cmdlet Select-Object, che cambiano il tipo di valore della proprietà.

Esempio 7: dividere i nomi dei moduli in nomi di componenti

Questo esempio mostra tre modi per dividere due nomi di moduli separati da punti nei loro nomi di componenti.

"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 "."MicrosoftPowerShellCoreMicrosoftPowerShellHost

I comandi chiamano il metodo Split delle stringhe. I tre comandi usano una sintassi diversa, ma sono equivalenti e intercambiabili.

Il primo comando usa la sintassi tradizionale, che include un blocco di script e l’operatore dell’oggetto corrente $_. Usa la sintassi dei punti per specificare il metodo e le parentesi per racchiudere il delimitatore dell’argomento.

Il secondo comando usa il parametro MemberName per specificare il metodo Split e il parametroArgumentName per identificare il punto (“.”) come delimitatore di divisione.

Il terzo comando usa l’alias Foreach della cmdlet ForEach-Object e omette i nomi dei parametri MemberName e ArgumentList, che sono opzionali.

Esempio 8: usare ForEach-Object con due blocchi di script

In questo esempio, passiamo due blocchi di script in posizione. Tutti i blocchi di script si legano al parametroProcess. Tuttavia, sono trattati come se fossero stati passati ai parametri Begin eProcess.

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

Esempio 9: usare ForEach-Object con più di due blocchi di script

In questo esempio, passiamo due blocchi di script in posizione. Tutti i blocchi di script si legano al parametroProcess. Tuttavia, sono trattati come se fossero stati passati ai parametri Begin, Process e End.

1..2 | ForEach-Object { 'begin' } { 'process A' } { 'process B' } { 'end' }beginprocess Aprocess Bprocess Aprocess Bend

Esempio 10: Eseguire più blocchi di script per ogni elemento della pipeline

Come mostrato nell’esempio precedente, più blocchi di script passati usando il parametro Process vengono mappati ai parametri Begin e End. Per evitare questa mappatura, è necessario fornire valori espliciti per i parametri Begin e End.

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

Esempio 11: Eseguire uno script lento in lotti paralleli

Questo esempio esegue un semplice blocco di script che valuta una stringa e dorme per un secondo.

$Message = "Output:"1..8 | ForEach-Object -Parallel { "$using:Message $_" Start-Sleep 1} -ThrottleLimit 4Output: 1Output: 2Output: 3Output: 4Output: 5Output: 6Output: 7Output: 8

Il valore del parametro ThrottleLimit è impostato a 4 in modo che l’input sia processato in lotti di quattro.La parola chiave $using: è usata per passare la variabile $Message in ogni blocco di script parallelo.

Esempio 12: Recupera voci di log in parallelo

Questo esempio recupera 50.000 voci di log da 5 log di sistema su una macchina Windows locale.

$logNames = 'Security','Application','System','Windows PowerShell','Microsoft-Windows-Store/Operational'$logEntries = $logNames | ForEach-Object -Parallel { Get-WinEvent -LogName $_ -MaxEvents 10000} -ThrottleLimit 5$logEntries.Count50000

Il parametro Parallel specifica il blocco di script che viene eseguito in parallelo per ogni nome di log in ingresso. Il parametro ThrottleLimit assicura che tutti e cinque i blocchi di script vengano eseguiti allo stesso tempo.

Esempio 13: Eseguire in parallelo come un lavoro

Questo esempio esegue un semplice blocco di script in parallelo, creando due lavori in background alla volta.

$job = 1..10 | ForEach-Object -Parallel { "Output: $_" Start-Sleep 1} -ThrottleLimit 2 -AsJob$job | Receive-Job -WaitOutput: 1Output: 2Output: 3Output: 4Output: 5Output: 6Output: 7Output: 8Output: 9Output: 10

la variabile $job riceve l’oggetto job che raccoglie i dati di output e controlla lo stato di esecuzione. E questo invia l’output alla console, proprio come se ForEach-Object -Parallel fosse stato eseguito senza AsJob.

Esempio 14: Usare riferimenti variabili sicuri per il thread

Questo esempio invoca blocchi di script in parallelo per raccogliere oggetti Process dal nome unico.

$threadSafeDictionary = ]::new()Get-Process | ForEach-Object -Parallel { $dict = $using:threadSafeDictionary $dict.TryAdd($_.ProcessName, $_)}$threadSafeDictionaryNPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName ------ ----- ----- ------ -- -- ----------- 82 82.87 130.85 15.55 2808 2 pwsh

Una singola istanza di un oggetto ConcurrentDictionary viene passata ad ogni blocco di script per raccogliere gli oggetti. Poiché il ConcurrentDictionary è thread safe, è sicuro di essere modificato da ogni script parallelo. Un oggetto non thread-safe, come System.Collections.Generic.Dictionary, non sarebbe sicuro da usare qui.

Esempio 15: Scrivere errori con l’esecuzione parallela

Questo esempio scrive nel flusso degli errori in parallelo, dove l’ordine degli errori scritti è casuale.

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

Esempio 16: Terminare gli errori in esecuzione parallela

Questo esempio dimostra un errore di terminazione in uno scriptblock in esecuzione parallela.

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

Output: 3 non viene mai scritto perché lo scriptblock parallelo per quella iterazione è terminato.

Esempio 17: Passare variabili in scriptBlockSet paralleli annidati

Si può creare una variabile al di fuori di un Foreach-Object -Parallel blocco di script con scope e usarla all’interno del blocco di script con la parola chiave $using.

$test1 = 'TestA'1..2 | Foreach-Object -Parallel { $using:test1}TestATestA# 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' cannot be retrieved because it has not been set in the local session.

Lo scriptblock annidato non può accedere alla variabile $test2 e viene lanciato un errore.

Parametri