ForEach-Object

ForEach-Object <ScriptBlock> >] 

ForEach-Object <String> >] 

ForEach-Object -Parallel <scriptblock> 

Exemplos

Exemplo 1: Divide inteiros num array

Este exemplo pega num array de três inteiros e divide cada um deles por 1024.

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

Exemplo 2: Obtenha o comprimento de todos os ficheiros num directório

Este exemplo processa os ficheiros e directórios no directório de instalação PowerShell $PSHOME.

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

Se o objecto não for um directório, o bloco de script recebe o nome do ficheiro, divide o valor da sua propriedade Length por 1024, e adiciona um espaço (” “) para o separar da entrada seguinte. Ocmdlet utiliza a propriedade PSISContainer para determinar se um objecto é um directório.

Exemplo 3: Operar nos eventos mais recentes do Sistema

Este exemplo escreve os 1000 eventos mais recentes do registo de eventos do Sistema para um ficheiro de texto. A hora actual é exibida antes e depois do processamento dos eventos.

$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 obtém os 1000 eventos mais recentes do registo de eventos do Sistema e armazena-os na variável$Events$Events é então canalizado para a variável ForEach-Object cmdlet. O parâmetro Begin exibe a data e hora actuais. A seguir, o parâmetro Process usa o Out-File cmdlet para criar um ficheiro de texto que se chama events.txt e armazena a propriedade de mensagem de cada um dos eventos nesse ficheiro. Por último, o parâmetro Fim é utilizado para mostrar a data e hora depois de todo o processamento ter terminado.

Exemplo 4: Alterar o valor de uma chave de Registo

Este exemplo altera o valor da entrada do registo RemotePath em todas as subchaves sob oHKCU:\Network chave para texto em maiúsculas.

P>Pode usar este formato para alterar a forma ou o conteúdo de uma entrada de registo.

Cada subchave na chave de Rede representa uma unidade de rede mapeada que volta a ligar-se ao iniciar a sessão. A entradaRemotePath contém o caminho UNC da unidade ligada. Por exemplo, se mapear a unidade E:drive para \\Server\Share, é criada uma subchave E em HKCU:\Network com o valor de registo do Caminho Remoto definido para \\Server\Share.

O comando usa o Get-ItemProperty cmdlet para obter todas as subchaves da chave de Rede e o comando Set-ItemProperty cmdlet para alterar o valor da entrada de registo do Caminho Remoto em cada chave. No comando Set-ItemProperty, o caminho é o valor da propriedade PSPath da chave de registo. Esta é uma propriedade do objecto Microsoft .NET Framework que representa a chave de registo, nota de entrada de registo. O comando usa o método ToUpper() do valor do Caminho Remoto, que é astring (REG_SZ).

p>Porque Set-ItemProperty altera a propriedade de cada chave, o ForEach-Object cmdlet é necessário para aceder à propriedade.

Exemplo 5: Usar a variável automática $Null

Este exemplo mostra o efeito de canalização da variável automática $Null para a variável automática ForEach-Objectcmdlet.

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

Porque o PowerShell trata nulo como um suporte de lugar explícito, o ForEach-Object cmdlet gera um aval para $Null, tal como faz para outros objectos que lhe canaliza.

Exemplo 6: Obter valores de propriedade

Este exemplo obtém o valor da propriedade Path de todos os módulos PowerShell instalados utilizando o parâmetro MemberName do ForEach-Object cmdlet.

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

O segundo comando é equivalente ao primeiro. Utiliza o Foreach alias do ForEach-Objectcmdlet e omite o nome do parâmetro MemberName, que é opcional.

O ForEach-Object cmdlet é útil para obter valores de propriedade, pois obtém o valor sem alterar o tipo, ao contrário do formato cmdlets ou do Select-Object cmdlet, que alteram o tipo de valor de propriedade.

Exemplo 7: Dividir os nomes dos módulos em nomes de componentes

Este exemplo mostra três formas de dividir dois nomes de módulos separados por pontos nos seus nomes de componentes.

"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

Os comandos chamam o método Split de cordas. Os três comandos utilizam uma sintaxe diferente, mas são equivalentes e intercambiáveis.

O primeiro comando utiliza a sintaxe tradicional, que inclui um bloco de script e o objectoperador actual $_. Utiliza a sintaxe do ponto para especificar o método e os parênteses para delimitar o delimitador.

O segundo comando utiliza o parâmetro MemberName para especificar o método Split e o parâmetroArgumentName para identificar o ponto (“.”) como o delimitador dividido.

O terceiro comando usa o parámetro Foreach do ForEach-Object cmdlet e omite os nomes dos parâmetros MemberName e ArgumentList, que são opcionais.

Exemplo 8: Usando ForEach-Object com dois blocos de script

Neste exemplo, passamos dois blocos de script em posição. Todos os blocos de script ligam-se ao parâmetroProcessar. Contudo, são tratados como se tivessem sido passados para os parâmetros Begin andProcess.

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

Exemplo 9: Usando ForEach-Object com mais de dois blocos de script

Neste exemplo, passamos dois blocos de script posicionados. Todos os blocos de script ligam-se ao parâmetroProcessar. No entanto, são tratados como se tivessem sido passados para os parâmetros Início, Processo e Fim.

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

Exemplo 10: Executar blocos de script múltiplos para cada item do gasoduto

Como mostrado no exemplo anterior, blocos de script múltiplos passados usando o parâmetro Processar são mapeados para os parâmetros Início e Fim. Para evitar este mapeamento, deve fornecer valores explícitos para os parâmetros Início e Fim.

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

Exemplo 11: Executar script lento em lotes paralelos

Este exemplo executa um bloco de script simples que avalia uma string e dorme durante um segundo.

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

O valor do parâmetro ThrottleLimit é definido para 4 de modo a que a entrada seja processada em lotes de quatro.O $using: palavra-chave é usada para passar o $Message variável em cada bloco de script paralelo.

Exemplo 12: Recuperar entradas de log em paralelo

Este exemplo recupera 50.000 entradas de log de 5 logs de sistema numa máquina Windows local.

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

O parâmetro Paralelo especifica o bloco de script que é executado em paralelo para cada logname de entrada. O parâmetro ThrottleLimit assegura que todos os cinco blocos de script sejam executados ao mesmo tempo.

Exemplo 13: Executar em paralelo como um job

Este exemplo executa um bloco de script simples em paralelo, criando dois jobs de fundo de cada vez.

$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

the $job variável recebe o objecto job que recolhe os dados de saída e monitoriza o estado de execução. O objecto job é canalizado para Receive-Job com o parâmetro Wait switch. E este fluxo de saída para a consola, tal como se ForEach-Object -Parallel fosse executado sem AsJob.

Exemplo 14: Usando referências de variáveis seguras de thread

Este exemplo invoca blocos de script em paralelo para recolher objectos de Processo de nome único.

$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

Uma única instância de um objecto de Dicionário Concorrente é passada para cada bloco de script para recolher os objectos. Uma vez que o ConcurrentDictionary é seguro para threads, é seguro ser modificado por cada script paralelo. Um objecto não seguro para threads, como System.Collections.Generic.Dictionary, não seria seguro de utilizar aqui.

Exemplo 15: Erros de escrita com execução paralela

Este exemplo escreve no fluxo de erros em paralelo, onde a ordem dos erros escritos é aleatória.

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

Exemplo 16: Erros de terminação em execução paralela

Este exemplo demonstra um erro de terminação num bloco de script paralelo em execução.

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

Output: 3 nunca é escrito porque o bloco de script paralelo para essa iteração foi terminado.

Exemplo 17: Passagem de variáveis em script paralelo aninhado ScriptBlockSet

É possível criar uma variável fora de um Foreach-Object -Parallel scoped scriptblock e utilizá-la dentro do scriptblock com a palavra-chave $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.

O bloco de script aninhado não pode aceder à variável $test2 e é lançado um erro.

Parametros

Inputs

PSObject

Pode canalizar qualquer objecto para este cmdlet.

Entradas

PSObject

Este cmdlet devolve objectos que são determinados pela entrada.

Notas

• p> O ForEach-Object cmdlet funciona muito como a declaração Foreach, excepto que não se pode canalizar a entrada para uma declaração Foreach. Para mais informações sobre a declaração de Foreach, ver sobre_Foreach.

• Iniciar em PowerShell 4.0, Where e ForEach foram adicionados métodos para utilização com colecções. Pode ler mais sobre estes novos métodos aqui sobre_arrays

• O conjunto de parâmetros ForEach-Object -Parallel utiliza o API interno do PowerShell para executar cada bloco de script. Isto é significativamente mais sobrecarregado do que correr ForEach-Object normalmente com processamento sequencial. É importante utilizar Paralelo onde a sobrecarga de correr em paralelo é pequena, para trabalhar o bloco de script executa. Por exemplo:

  • Compute scripts intensivos em máquinas multi-core
  • Scripts que passam tempo à espera de resultados ou a fazer operações de ficheiro

  Usar o parâmetro Paralelo pode fazer com que os scripts sejam executados muito mais lentamente do que o normal. Especialmente se os scripts paralelos forem triviais. Experimente com Paralelo para descobrir onde pode bebereneficial.

  Importante

  O parâmetro ForEach-Object -Parallel executa blocos de scripts em paralelo em procstreads separados. O $using: palavra-chave permite passar referências variáveis da invocação cmdlet para cada linha de bloco de script em execução. Uma vez que os blocos de script rodam em diferentes threads, as variáveis do objecto passadas por referência devem ser utilizadas com segurança. Geralmente é seguro ler a partir de objectos referenciados que não mudam. Mas se o estado do objecto estiver a ser modificado, então deve utilizar objectos seguros de threads, tais como .Net System.Collection.Concurrent types (Ver Exemplo 11).

• Compare-Objecto
• Where-Objecto
• Grupo-Objecto
• Measure-Objecto
• Novo-Objecto
• Select-Objecto
• Sort-Objecto
• Tee-Objecto