PowerShell
Boucles

Introduction

Syntaxe

• pour (<Initialisation>; <Condition>; <Répétition>) {<Script_Block>}

• <Collection> | Foreach-Object {<Script_Block_with _ $ __ as_current_item>}

• foreach (<Item> dans <Collection>) {<Script_Block>}

• while (<Condition>) {<Script_Block>}

• faire {<Script_Block>} while (<Condition>)

• faire {<Script_Block>} jusqu'à (<Condition>)

• <Collection> .foreach ({<Script_Block_with _ $ __ as_current_item>})

Remarques

$foreach = Measure-Command { foreach ($i in (1..1000000)) { $i * $i } }
$foreachmethod = Measure-Command { (1..1000000).ForEach{ $_ * $_ } }
$foreachobject = Measure-Command { (1..1000000) | ForEach-Object { $_ * $_ } }

"Foreach: $($foreach.TotalSeconds)"
"Foreach method: $($foreachmethod.TotalSeconds)"
"ForEach-Object: $($foreachobject.TotalSeconds)"

Example output:

Foreach: 1.9039875
Foreach method: 4.7559563
ForEach-Object: 10.7543821

Pour

for($i = 0; $i -le 5; $i++){
    "$i"
}

Une utilisation typique de la boucle for consiste à opérer sur un sous-ensemble des valeurs d'un tableau. Dans la plupart des cas, si vous souhaitez parcourir toutes les valeurs d'un tableau, envisagez d'utiliser une instruction foreach.

Pour chaque

ForEach a deux significations différentes dans PowerShell. L'un est un mot - clé et l'autre est un alias pour l' applet de commande ForEach-Object . Le premier est décrit ici.

Cet exemple montre comment imprimer tous les éléments d'un tableau sur l'hôte de la console:

$Names = @('Amy', 'Bob', 'Celine', 'David')

ForEach ($Name in $Names)
{
    Write-Host "Hi, my name is $Name!"
}

Cet exemple montre comment capturer la sortie d'une boucle ForEach:

$Numbers = ForEach ($Number in 1..20) {
    $Number # Alternatively, Write-Output $Number
}

Comme dans le dernier exemple, cet exemple montre plutôt la création d’un tableau avant le stockage de la boucle:

$Numbers = @()
ForEach ($Number in 1..20)
{
    $Numbers += $Number
}

Tandis que

Une boucle while évalue une condition et si true exécute une action. Tant que la condition est vraie, l'action continuera d'être effectuée.

while(condition){
  code_block
}

L'exemple suivant crée une boucle qui comptera de 10 à 0

$i = 10
while($i -ge 0){
    $i
    $i--
}

Contrairement à la boucle Do -While, la condition est évaluée avant la première exécution de l'action. L'action ne sera pas effectuée si la condition initiale est fausse.

Remarque: Lors de l'évaluation de la condition, PowerShell considère que l'existence d'un objet de retour est vraie. Cela peut être utilisé de plusieurs manières, mais ci-dessous est un exemple pour surveiller un processus. Cet exemple va engendrer un processus de bloc-notes et ensuite dormir le shell en cours tant que ce processus est en cours d'exécution. Lorsque vous fermez manuellement l'instance du bloc-notes, la condition while va échouer et la boucle sera interrompue.

Start-Process notepad.exe
while(Get-Process notepad -ErrorAction SilentlyContinue){
  Start-Sleep -Milliseconds 500
}

ForEach-Object

L' ForEach-Object fonctionne de manière similaire à l'instruction foreach , mais tire son entrée du pipeline.

Utilisation de base

$object | ForEach-Object {
    code_block
}

Exemple:

$names = @("Any","Bob","Celine","David")
$names | ForEach-Object {
    "Hi, my name is $_!"
}

Foreach-Object a deux alias par défaut, foreach et % (syntaxe abrégée). Le plus courant est % car foreach peut être confondu avec l' instruction foreach . Exemples:

$names | % {  
    "Hi, my name is $_!"
} 

$names | foreach {  
    "Hi, my name is $_!"
} 

Utilisation avancée

Foreach-Object se distingue des solutions foreach alternatives car il s'agit d'une applet de commande qui signifie qu'il est conçu pour utiliser le pipeline. De ce fait, il prend en charge trois blocs de script, tout comme une applet de commande ou une fonction avancée:

• Begin : Exécuté une fois avant de parcourir les éléments qui arrivent du pipeline. Généralement utilisé pour créer des fonctions à utiliser dans la boucle, créer des variables, ouvrir des connexions (base de données, web +), etc.
• Processus : exécuté une fois par article arrivé du pipeline. "Normal" foreach codeblock. C'est la valeur par défaut utilisée dans les exemples ci-dessus lorsque le paramètre n'est pas spécifié.
• End : Exécuté une fois après avoir traité tous les éléments. Généralement utilisé pour fermer des connexions, générer un rapport, etc.

Exemple:

"Any","Bob","Celine","David" | ForEach-Object -Begin {
    $results = @()
} -Process {
    #Create and store message
    $results += "Hi, my name is $_!"
} -End {
    #Count messages and output
    Write-Host "Total messages: $($results.Count)"
    $results
}

Faire

Les Do-Loops sont utiles lorsque vous voulez toujours exécuter au moins une fois un bloc de code. Une Do-loop évaluera la condition après l'exécution du codeblock, contrairement à une boucle while qui le fait avant d'exécuter le codeblock.

Vous pouvez utiliser les boucles de deux manières:

• Boucle tant que la condition est vraie:

  Do {
      code_block
  } while (condition)
  

• Boucle jusqu'à ce que la condition soit vraie, en d'autres termes, boucle pendant que la condition est fausse:

  Do {
      code_block
  } until (condition)
  

Exemples réels:

$i = 0

Do {
    $i++
    "Number $i"
} while ($i -ne 3)

Do {
    $i++
    "Number $i"
} until ($i -eq 3)

Do-While et Do-Until sont des boucles antonymous. Si le code à l'intérieur du même, la condition sera inversée. L'exemple ci-dessus illustre ce comportement.

Méthode ForEach ()

(1..10).ForEach({$_ * $_})

(1..10).ForEach{$_ * $_}  

1
4
9
16
25
36
49
64
81
100  

Continuer

L'opérateur Continue fonctionne dans les boucles For , ForEach , While et Do Il ignore l'itération actuelle de la boucle, en sautant au sommet de la boucle la plus interne.

$i =0
while ($i -lt 20) {
    $i++ 
    if ($i -eq 7) { continue }
    Write-Host $I
}

Le résultat ci-dessus produira 1 à 20 sur la console mais manquera le numéro 7.

Remarque : Lorsque vous utilisez une boucle de pipeline, vous devez utiliser return au lieu de Continue .

Pause

L'opérateur de break sortira immédiatement d'une boucle de programme. Il peut être utilisé dans les boucles For , ForEach , While et Do ou dans une instruction Switch .

$i = 0
while ($i -lt 15) {
    $i++ 
    if ($i -eq 7) {break}
    Write-Host $i
}

Ce qui précède comptera jusqu'à 15 mais s'arrêtera dès que 7 sera atteint.

Remarque : Lorsque vous utilisez une boucle de pipeline, la break se comportera comme si elle se continue . Pour simuler des break dans la boucle de pipeline, vous devez intégrer une logique, une cmdlet, etc. supplémentaires. Il est plus facile de rester en contact avec des boucles sans pipeline si vous avez besoin d'utiliser break .

Étiquettes de rupture

Break peut également appeler une étiquette placée devant l'instanciation d'une boucle:

$i = 0
:mainLoop While ($i -lt 15) {
    Write-Host $i -ForegroundColor 'Cyan'
    $j = 0
    While ($j -lt 15) {
        Write-Host $j -ForegroundColor 'Magenta'
        $k = $i*$j
        Write-Host $k -ForegroundColor 'Green'
        if ($k -gt 100) {
            break mainLoop
        }
        $j++
    }
    $i++
}

Remarque: Ce code incrémente $i à 8 et $j à 13 ce qui fait que $k égal à 104 . Comme $k dépasse 100 , le code va alors sortir des deux boucles.