RUBRIQUE
about_Foreach
DESCRIPTION COURTE
Décrit une commande de langage permettant de parcourir tous les
éléments d'une collection d'éléments.
DESCRIPTION LONGUE
L'instruction Foreach (également appelée " boucle Foreach ") est une
construction de langage permettant de parcourir une série de valeurs
présentes dans une collection d'éléments (c'est-à-dire d'effectuer
des itérations dans ces valeurs).
Le type de collection le plus simple et le plus classique à
parcourir est le tableau. Dans une boucle Foreach, il est
fréquent d'exécuter une ou plusieurs commandes sur chaque
élément d'un tableau.
Syntaxe
La syntaxe de l'instruction Foreach est présentée ci-dessous.
foreach ($<élément> in $<collection>){<liste d'instructions>}
Instruction Foreach située hors d'un pipeline de commande La partie de
l'instruction Foreach figurant entre parenthèses représente une
variable et une collection à parcourir. Windows PowerShell crée
automatiquement la variable ($<élément>) lorsque la boucle
Foreach s'exécute. Avant chaque passage dans la boucle,
la variable est définie sur une valeur de la collection.
Le bloc qui suit une instruction Foreach {<liste d'instructions>}
contient un jeu de commandes à exécuter sur chaque élément d'une
collection.
Exemples
La boucle Foreach de 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 tableau $letterArray est créé et
initialisé avec les valeurs de chaîne " a ", " b ", " c " et
" d ". Lors de sa première exécution, l'instruction Foreach
affecte à la variable $letter la valeur du premier élément du
tableau $letterArray (" a "). Elle utilise ensuite l'applet de
commande Write-Host pour afficher la lettre a. Au passage
suivant dans la boucle, $letter prend la valeur " b ", et ainsi
de suite. Une fois que la boucle Foreach a affiché la lettre d,
Windows PowerShell quitte la boucle.
L'instruction Foreach entière doit figurer sur une seule ligne pour
pouvoir être exécutée en tant que commande à l'invite de commandes de
Windows PowerShell. Cette condition n'est pas requise si vous placez
la commande dans un fichier de script .ps1.
Les instructions Foreach peuvent également être utilisées avec
des applets de commande qui retournent une collection d'éléments.
Dans l'exemple suivant, l'instruction Foreach parcourt la liste
d'éléments retournée par l'applet de commande Get-ChildItem :
foreach ($file in Get-ChildItem)
{
Write-Host $file
}
Vous pouvez affiner l'exemple en utilisant une instruction If
afin de limiter les résultats retournés. Dans l'exemple suivant,
l'instruction Foreach exécute la même opération de bouclage que dans
l'exemple précédent, mais ajoute une instruction If pour limiter les
résultats aux fichiers dont la taille dépasse 100 kilo-octets (Ko) :
foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file
}
}
Dans cet exemple, la boucle Foreach utilise une propriété de la
variable $file pour effectuer une comparaison ($file.length -gt
100k). La variable $file contient toutes les propriétés de l'objet
retourné par l'applet de commande Get-ChildItem. Par conséquent,
vous pouvez retourner plus qu'un simple nom de fichier. Dans
l'exemple suivant, Windows PowerShell retourne la longueur
et l'heure du dernier accès dans la liste d'instructions :
foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file
Write-Host $file.length
Write-Host $file.lastaccesstime }
}
Dans cet exemple, vous n'êtes pas limité à l'exécution d'une simple
commande dans une liste d'instructions.
Vous pouvez également utiliser une variable en dehors d'une
boucle Foreach et l'incrémenter dans la boucle. Dans l'exemple
suivant, les fichiers dont la taille est supérieure à 100 Ko sont
comptabilisés :
$i = 0
foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file "taille du fichier :" ($file.length /
1024).ToString("F0") KB
$i = $i + 1
}
}
if ($i -ne 0)
{
Write-Host
Write-Host $i " fichier(s) de plus de 100 Ko dans le
répertoire actif."}
else
{
Write-Host "Aucun fichier de plus de 100 Ko dans le
répertoire actif."
}
Dans l'exemple précédent, la variable $i est définie sur 0 en
dehors de la boucle et incrémentée dans la boucle pour chaque
fichier trouvé dont la taille est supérieure à 100 Ko. À la
sortie de la boucle, une instruction If évalue la valeur de la
variable $i pour afficher le nombre total de fichiers dont la taille
dépasse 100 Ko. Elle peut également afficher un message indiquant qu'aucun
fichier de plus de 100 Ko n'a été trouvé.
L'exemple précédent montre également comment mettre en forme
les résultats de longueur de fichier :
($file.length / 1024).ToString("F0")
La valeur est divisée par 1 024 pour afficher le résultat en
kilo-octets plutôt qu'en octets et la valeur obtenue est
ensuite mise en forme à l'aide du spécificateur de format en
virgule fixe afin de supprimer les valeurs décimales du
résultat. Le 0 indique au spécificateur de format qu'il ne doit pas
afficher de décimales.
Instruction Foreach dans un pipeline de commande Lorsqu'une instruction
Foreach apparaît dans un pipeline de commande, Windows PowerShell
utilise l'alias foreach, qui appelle la commande ForEach-Object.
Lorsque vous employez l'alias foreach dans un pipeline de commande,
vous n'incluez pas la syntaxe ($<élément> in $<collection>) de la
même manière qu'avec l'instruction Foreach. En effet, la commande
antérieure dans le pipeline fournit cette information. Lorsque
l'alias foreach est utilisé dans un pipeline de commande,
sa syntaxe se présente comme suit :
<commande> | foreach {<bloc_commandes>}
Par exemple, la boucle Foreach du pipeline de commande
ci-dessous affiche tous les processus dont la plage de travail
(utilisation de la mémoire) est supérieure à 20 mégaoctets (Mo). Windows
PowerShell dirige la sortie de la commande Get-Process vers l'alias
foreach. Dans le bloc de commandes de l'alias foreach, la variable
$_.WS contient la valeur de la propriété WS (plage de travail) qui lui
est passée par l'applet de commande Get-Process. (La partie $_ de la
déclaration est une variable automatique WSH [Windows Script Host] et
la partie WS est une propriété.) L'instruction If utilise une instruction
conditionnelle pour déterminer si la plage de travail est supérieure
à 20 Mo (20 000 000 octets). Si tel est le cas, le nom du processus,
qui est stocké dans la variable $_.name, et la taille de la plage de
travail en mégaoctets sont affichés. Si aucune plage de travail ne
dépasse 20 Mo, aucune donnée ne s'affiche.
Write-Host "Processus dont la plage de travail dépasse
20 Mo" Get-Process | foreach {
if ($_.WS -gt 20m)
{
Write-Host $_.name ": "
($_.WS/1m).ToString("F0") MB -Separator ""
}
}
L'alias foreach prend également en charge les blocs de
commandes de début, centraux et de fin. Les blocs de commandes
de début et de fin s'exécutent une fois, tandis que le bloc de
commandes central s'exécute chaque fois que la boucle Foreach
parcourt une collection ou un tableau.
Lorsque l'alias foreach est utilisé dans un pipeline de
commande avec des blocs de commandes de début, central et
de fin, sa syntaxe est la suivante :
<commande> | foreach {<bloc de commandes de début>}{<bloc
de commandes central>}{<bloc de commandes de fin>}
L'exemple suivant illustre l'utilisation des blocs de commandes
de début, central et de fin :
Get-ChildItem | foreach {
$fileCount = $directoryCount = 0}{
if ($_.PsIsContainer) {$directoryCount++} else
{$fileCount++}}{ "$directoryCount répertoires and $fileCount fichiers"}
Le bloc de début crée deux variables et les initialise sur 0 :
{$fileCount = $directoryCount = 0}
Le bloc central évalue si chaque élément retourné par
Get-ChildItem est un répertoire ou un fichier :
{if ($_.PsIsContainer) {$directoryCount++} else {$fileCount++}}
Si l'élément retourné est un répertoire, la variable
$directoryCount est incrémentée d'une unité. Si l'élément n'est
pas un répertoire, la variable $fileCount est incrémentée d'une
unité. Le bloc de fin s'exécute lorsque le bloc central a
terminé son opération de boucle, puis retourne les résultats de
l'opération :
{"$directoryCount répertoires and $fileCount fichiers"}
En utilisant la structure des blocs de commandes de début,
central et de fin, ainsi que l'opérateur de pipeline, vous
pouvez réécrire l'exemple précédent pour trouver les fichiers
dont la taille est supérieure à 100 Ko, comme suit :
Get-ChildItem | foreach{
$i = 0}{
if ($_.length -gt 100k)
{
Write-Host $_.name "taille du fichier :" ($_.length /
1024).ToString("F0") KB
$i++
}
}{
if ($i -ne 0)
{
Write-Host
Write-Host "$i fichier(s) de plus de 100 Ko dans le
répertoire actif."
}
else
{
Write-Host "Aucun fichier de plus de 100 Ko dans le
répertoire actif."}
}
VOIR AUSSI
about_Automatic_Variables
about_If
Foreach-Object