about_Foreach

  • Article

Description courte

Décrit une commande de langage que vous pouvez utiliser pour parcourir tous les éléments d’une collection d’éléments.

Description longue

L’instruction foreach est une construction de langage pour itérer sur un ensemble de valeurs dans une collection.

Le type de collection le plus simple et le plus classique à parcourir est un tableau. Dans une foreach boucle, il est courant d’exécuter une ou plusieurs commandes sur chaque élément d’un tableau.

Syntaxe

Voici la foreach syntaxe suivante :

foreach ($<item> in $<collection>){<statement list>}

La partie de l’instruction foreach entre parenthèses représente une variable et une collection à itérer. PowerShell crée automatiquement la variable $<item> lors de l’exécution de la foreach boucle. Au début de chaque itération, foreach définit la variable d’élément sur la valeur suivante de la collection. Le {<statement list>} bloc contient les commandes à exécuter pour chaque itération.

Exemples

Par exemple, la foreach boucle de l’exemple suivant affiche les valeurs du $letterArray tableau.

$letterArray = 'a','b','c','d'
foreach ($letter in $letterArray)
{
  Write-Host $letter
}

Dans cet exemple, le $letterArray fichier contient les valeurs ade chaîne , b, cet d. La première fois que l’instruction foreach s’exécute, elle définit la $letter variable égale au premier élément dans $letterArray (a). Ensuite, il utilise Write-Host pour afficher la valeur. La prochaine fois dans la boucle, $letter est définie sur b. Le modèle se répète pour chaque élément du tableau.

Vous pouvez également utiliser foreach des instructions avec des applets de commande qui retournent une collection d’éléments. Dans l’exemple suivant, l’instruction foreach décrit la liste des éléments retournés par l’applet Get-ChildItem de commande.

foreach ($file in Get-ChildItem)
{
  Write-Host $file
}

Vous pouvez affiner l’exemple à l’aide d’une if instruction pour limiter les résultats retournés. Dans l’exemple suivant, l’instruction if limite les résultats aux fichiers supérieurs à 100 kilo-octets (Ko) :

foreach ($file in Get-ChildItem)
{
  if ($file.Length -gt 100KB)
  {
    Write-Host $file
  }
}

Dans cet exemple, la foreach boucle utilise une propriété de la $file variable pour effectuer une opération de comparaison ($file.length -gt 100KB). La $file variable a toutes les propriétés de l’objet retourné par le Get-ChildItem.

Dans l’exemple suivant, le script affiche la longueur et la dernière heure d’accès dans la liste des instructions :

foreach ($file in Get-ChildItem)
{
  if ($file.Length -gt 100KB)
  {
    Write-Host $file
    Write-Host $file.Length
    Write-Host $file.LastAccessTime
  }
}

Vous pouvez également utiliser des variables en dehors d’une foreach boucle. L’exemple suivant compte plus de 100 fichiers Ko de taille :

$i = 0
foreach ($file in Get-ChildItem) {
  if ($file.length -gt 100KB) {
    Write-Host $file 'file size:' ($file.length / 1024).ToString('F0') KB
    $i = $i + 1
  }
}

if ($i -ne 0) {
  Write-Host
  Write-Host $i ' file(s) over 100KB in the current directory.'
}
else {
  Write-Host 'No files greater than 100KB in the current directory.'
}

Dans l’exemple précédent, $i commence par une valeur de l’extérieur de 0 la boucle. Ensuite, $i est incrémenté à l’intérieur de la boucle pour chaque fichier supérieur à 100 Ko. Lorsque la boucle se termine, une if instruction évalue la valeur de $i l’affichage d’un nombre de fichiers supérieur à 100 Ko.

L’exemple précédent montre également comment mettre en forme les résultats de longueur du fichier :

($file.length / 1024).ToString('F0')

La valeur est divisée par 1 024 pour afficher les résultats en kilo-octets plutôt que en octets, et la valeur obtenue est ensuite mise en forme à l’aide du spécificateur de format à virgule fixe pour supprimer les valeurs décimales du résultat. Le 0 spécificateur de format n’affiche pas de décimales.

La fonction suivante analyse les scripts PowerShell et les modules de script et retourne l’emplacement des fonctions contenues dans. L’exemple montre comment utiliser la MoveNext méthode et la Current propriété de la variable à l’intérieur $foreach d’un foreach bloc de script.

Pour plus d’informations, consultez Utilisation des énumérateurs.

function Get-FunctionPosition {
  [CmdletBinding()]
  [OutputType('FunctionPosition')]
  param(
    [Parameter(Position = 0, Mandatory,
      ValueFromPipeline, ValueFromPipelineByPropertyName)]
    [ValidateNotNullOrEmpty()]
    [Alias('PSPath')]
    [System.String[]]
    $Path
  )

  process {
    try {
      $filesToProcess = if ($_ -is [System.IO.FileSystemInfo]) {
        $_
      } else {
        Get-Item -Path $Path
      }
      $parser = [System.Management.Automation.Language.Parser]
      foreach ($item in $filesToProcess) {
        if ($item.PSIsContainer -or
            $item.Extension -notin @('.ps1', '.psm1')) {
          continue
        }
        $tokens = $errors = $null
        $ast = $parser::ParseFile($item.FullName, ([ref]$tokens),
          ([ref]$errors))
        if ($errors) {
          $msg = "File '{0}' has {1} parser errors." -f $item.FullName,
            $errors.Count
          Write-Warning $msg
        }
        :tokenLoop foreach ($token in $tokens) {
          if ($token.Kind -ne 'Function') {
            continue
          }
          $position = $token.Extent.StartLineNumber
          do {
            if (-not $foreach.MoveNext()) {
              break tokenLoop
            }
            $token = $foreach.Current
          } until ($token.Kind -in @('Generic', 'Identifier'))
          $functionPosition = [pscustomobject]@{
            Name       = $token.Text
            LineNumber = $position
            Path       = $item.FullName
          }
          $addMemberSplat = @{
              InputObject = $functionPosition
              TypeName = 'FunctionPosition'
              PassThru = $true
          }
          Add-Member @addMemberSplat
        }
      }
    }
    catch {
      throw
    }
  }
}

Voir aussi