Compartilhar via


about_Foreach

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