TÓPICO
about_Foreach
DESCRIÇÃO RESUMIDA
Descreve um comando de linguagem que você pode usar para
percorrer todos os itens em uma coleção de itens.
DESCRIÇÃO LONGA
A instrução Foreach (também conhecida como loop Foreach) é uma
construção de linguagem para percorrer (iterando) uma série de
valores de uma coleção de itens.
O tipo mais simples e o mais comum de coleção a ser percorrida é
uma matriz.
Dentro de um loop Foreach, é comum a execução de um ou mais
comandos para cada item de uma matriz.
Sintaxe
Esta é a sintaxe de Foreach:
foreach ($<item> in $<coleção>){<lista de instruções>}
A instrução Foreach fora de um pipeline de comandos A parte da instrução
Foreach entre parênteses representa uma variável e uma coleção a ser
iterada. O Windows PowerShell cria a variável ($<item>)
automaticamente quando o loop Foreach é executado. Antes de
cada repetição através do loop, a variável é definida como um valor
da coleção. O bloco a seguir à instrução Foreach {<lista de
instruções>} contém um conjunto de comandos a ser executado para
cada item de uma coleção.
Exemplos
Por exemplo, o loop Foreach a seguir mostra os valores na matriz
$letterArray:
$letterArray = "a","b","c","d"
foreach ($letter in $letterArray)
{
Write-Host $letter
}
Neste exemplo, a matriz $letterArray é criada e inicializada com os
valores de cadeia de caracteres "a", "b", "c" e "d". A primeira vez
em que a instrução Foreach é executada, ela define a variável $letter
como sendo igual ao primeiro item de $letterArray ("a"). Em seguida,
ela usa o cmdlet Write-Host para exibir a letra a. Na próxima vez que
o loop é percorrido, $letter é definida como "b", e assim por diante.
Depois que o loop Foreach exibe a letra d, o Windows PowerShell sai
do loop.
Toda a instrução Foreach precisa aparecer em uma única linha
para ser executada como um comando no prompt de comando do Windows
PowerShell. A instrução Foreach inteira não precisa aparecer em uma
única linha se você colocar o comando em um arquivo de script .ps1.
As instruções Foreach também podem ser usadas em conjunto com
cmdlets para retornar uma coleção de itens. No exemplo a seguir, a
instrução Foreach percorre a lista de itens retornada pelo cmdlet
Get-ChildItem.
foreach ($file in Get-ChildItem)
{
Write-Host $file
}
Você pode refinar o exemplo usando uma instrução If para limitar os
resultados retornados. No exemplo a seguir, a instrução Foreach
executa a mesma operação de loop do exemplo anterior, mas adiciona
uma instrução If para limitar os resultados aos arquivos com tamanho
maior do que 100 kilobytes (KB):
foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file
}
}
Neste exemplo, o loop Foreach usa uma propriedade da variável
$file para executar uma operação de comparação ($file.length
-gt 100k). A variável $file contém todas as propriedades do objeto
retornado pelo cmdlet Get-ChildItem. Portanto, você pode retornar
mais do que apenas um nome de arquivo. No próximo exemplo, o Windows
PowerShell retorna o tamanho e o último horário de acesso na lista de
instruções:
foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file
Write-Host $file.length
Write-Host $file.lastaccesstime }
}
Neste exemplo, você não está limitado a executar um único
comando em uma lista de instruções.
Você também pode usar uma variável fora de um loop Foreach e
incrementar a variável dentro do loop. O exemplo a seguir conta
arquivos de mais de 100 KB de tamanho:
$i = 0
foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file "tamanho do arquivo:" ($file.length /
1024).ToString("F0") KB
$i = $i + 1
}
}
if ($i -ne 0)
{
Write-Host
Write-Host $i " arquivo(s) com mais de 100 KB no
diretório atual."}
else
{
Write-Host "Nenhum arquivo maior do que 100 KB no
diretório atual."
}
No exemplo anterior, a variável $i foi definida como 0 fora do
loop e incrementada dentro dele para cada arquivo encontrado
maior do que 100 KB. Quando o loop termina, uma instrução If
avalia o valor de $i para exibir uma contagem de todos os
arquivos com mais de 100 KB. Ou exibe uma mensagem declarando
que nenhum arquivo acima de 100 KB foi encontrado.
O exemplo anterior também demonstra como formatar os resultados
de tamanho do arquivo:
($file.length / 1024).ToString("F0")
O valor é dividido por 1.024 para mostrar os resultados em
kilobytes, e não em bytes, e o valor resultante é então
formatado com o uso do especificador de formato de ponto fixo,
que remove valores decimais do resultado. O 0 faz com que o
especificador de formato não mostre casas decimais.
A instrução Foreach dentro de um pipeline de comandos Quando
Foreach aparece em um pipeline de comandos, o Windows PowerShell
utiliza o alias foreach, que chama o comando ForEach-Object. Ao
usar o alias foreach em um pipeline de comandos, você não inclui a
sintaxe ($<item> in $<coleção>) como faz com a instrução Foreach. Isso
acontece porque o comando anterior no pipeline fornece essas
informações. A sintaxe do alias foreach quando usado em um pipeline
de comandos é a seguinte:
<comando> | foreach {<bloco_de_comando>}
Por exemplo, o loop Foreach no seguinte pipeline de comandos exibe
qualquer processo cujo conjunto de trabalho (uso de memória) seja
maior do que 20 megabytes (MB). O Windows PowerShell envia a saída do
comando Get-Process para o alias foreach. Dentro do bloco de comandos
do alias foreach, a variável $_.WS contém o valor da propriedade WS
(conjunto de trabalho) passada pelo cmdlet Get-Process. (O trecho
$_ da declaração é uma variável automática WSH (Windows Script Host),
e o trecho WS é uma propriedade). A instrução If utiliza uma instrução
condicional para determinar se o conjunto de trabalho é maior do que
20 MB (20.000.000 bytes). Caso seja, o nome do processo armazenado na
variável $_.name e o tamanho do conjunto de trabalho em megabytes são
exibidos.Se nenhum conjunto de trabalho de processo for maior do que
20 MB, nada será exibido.
Write-Host "Processos com conjuntos de trabalho maiores do
que 20 MB" Get-Process | foreach {
if ($_.WS -gt 20m)
{
Write-Host $_.name ": "
($_.WS/1m).ToString("F0") MB -Separator "" }
}
O alias foreach também oferece suporte a blocos de comandos
iniciais, blocos de comandos intermediários e blocos de
comandos finais. Os blocos de comandos inicial e final são
executados uma vez, enquanto o intermediário é executado sempre
que o loop Foreach percorre uma coleção ou uma matriz.
A sintaxe do alias foreach quando usado em um pipeline de
comandos com um conjunto inicial, intermediário e final de blocos de
comandos é a seguinte:
<comando> | foreach {<bloco_de_comando inicial>}{<bloco_de_c
omando intermediário>}{<bloco_de_comando final>}
O exemplo a seguir demonstra o uso dos blocos de comandos inicial,
intermediário e final.
Get-ChildItem | foreach {
$fileCount = $directoryCount = 0}{
if ($_.PsIsContainer) {$directoryCount++} else {$fileCount++}}{
"$directoryCount diretórios e $fileCount arquivos"}
O bloco inicial cria e inicializa duas variáveis como 0:
{$fileCount = $directoryCount = 0}
O bloco intermediário avalia se cada item retornado por
Get-ChildItem é um diretório ou um arquivo:
{if ($_.PsIsContainer) {$directoryCount++} else {$fileCount++}}
Se o item retornado for um diretório, a variável $directoryCount
será incrementada em 1. Se o item não for um diretório, a variável
$fileCount será incrementada em 1. O bloco final será executado
depois que o bloco intermediário concluir sua operação de loop e
retornar os resultados da operação:
{"$directoryCount diretórios e $fileCount arquivos"}
Usando a estrutura de blocos de comandos inicial, intermediário
e final e o operador pipeline, você pode reescrever o primeiro
exemplo para encontrar qualquer arquivo que seja maior do que
100 KB, da seguinte forma.
Get-ChildItem | foreach{
$i = 0}{
if ($_.length -gt 100k)
{
Write-Host $_.name "tamanho do arquivo:" ($_.length /
1024).ToString("F0") KB
$i++
}
}{
if ($i -ne 0)
{
Write-Host
Write-Host "$i arquivo(s) com mais de 100 KB no
diretório atual."
}
else
{
Write-Host "Nenhum arquivo maior do que 100 KB no
diretório atual."}
}
CONSULTE TAMBÉM
about_Automatic_Variables
about_If
Foreach-Object