Partager via

about_Foreach

Brève description

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 effectuer une itération 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 boucle foreach, il est courant d’exécuter une ou plusieurs commandes sur chaque élément d’un tableau.

Syntaxe

Voici la syntaxe foreach :

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 la variable $<item> automatiquement lorsque la boucle foreach s’exécute. Au début de chaque itération, foreach définit la variable d’élément sur la valeur suivante de la collection. Le bloc {<statement list>} contient les commandes à exécuter pour chaque itération.

Exemples

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

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

Dans cet exemple, le $letterArray contient les valeurs de chaîne a, b, cet d. La première fois que l’instruction foreach s’exécute, elle définit la variable $letter égale au premier élément de $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 des instructions foreach 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 de commande Get-ChildItem.

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

Vous pouvez affiner l’exemple à l’aide d’une instruction if 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 boucle foreach utilise une propriété de la variable $file pour effectuer une opération de comparaison ($file.Length -gt 100KB). La variable $file 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 boucle foreach. L’exemple suivant compte plus de 100 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 0 en dehors de 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 instruction if évalue la valeur de $i pour afficher le nombre de fichiers de plus de 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 rend le spécificateur de format sans 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 bloc d’instructions foreach .

Pour plus d’informations, consultez Using Enumerators.

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

  • Last updated on