PowerShell For Loop, ForEach et Do While/Until Explained

L’une des fonctions les plus fondamentales de la programmation, outre « If, Else », sont les boucles. Ils vous permettent de traiter des données ou d'exécuter une fonction jusqu'à ce qu'une certaine condition soit atteinte. En PowerShell, nous pouvons utiliser différents types de bouclesBoucle For, ForEach, While, Do While, etFaire jusqu'à.

Savoir quand utiliser ce qui est important pour écrire de meilleurs scripts Powershell. La différence entre les trois boucles while est parfois difficile à comprendre.

Dans cet article, nous allons examiner les différentes fonctions de boucle que nous pouvons utiliser dans PowerShell, comment les utiliser et quelles sont les différences entre elles.

Powershell pour boucle

La boucle For dans PowerShell est à peu près la boucle la plus basique que vous puissiez utiliser. Il parcourt un nombre spécifié de fois dans une partie du script jusqu'à ce que la condition soit remplie.

Pour utiliser la boucle For dans PowerShell, vous devrez spécifier un compteur$i, l'état$i -lt 5(exécutez tant que $i est inférieur à 5) et augmentez le compteur.

For ($i = 0; $i -lt 5; $i++) {
    Write-host $i 
}

L'augmentation du compteur peut également être effectuée à l'intérieur du script. Cela vous permet d'augmenter le compteur uniquement lorsqu'une condition spécifique est remplie dans votre script.

For ($i = 0; $i -lt 5) {
    Write-Host $i;    
    $i++
}

Vous pouvez également parcourir un tableau avec une simple boucle For dans PowerShell. Nous pouvons prendre lelongueur du tableaudans le cadre de la condition et parcourez le tableau jusqu'à ce que nous ayons traité tous les éléments du tableau.

Il est plus facile d'utiliser une boucle foreach pour traiter un tableau qu'une boucle for, nous en reparlerons plus tard.

$fruit = @('apple','pear','banana','lemon','lime','mango')

# -le means less or equal to
For ($i = 0; $i -le $fruit.length; $i++) {
    Write-Host $fruit[$i];    
}

PowerShell Foreach 1..10

PowerShell dispose également d'un raccourci que vous pouvez utiliser pour une boucle. Vous pouvez définir une plage, par exemple,1..10puis parcourez chaque nombre de la plage avec une instruction ForEach. Cela vous permet de spécifier combien de fois vous souhaitez exécuter le script et de simplement diriger le script derrière lui.

$path = "C:\temp"

# Create a new file ForEach 1..10 number 
1..10 | % {
    $newFile = "$path\test_file_" + $_ + ".txt";
    New-Item $newFile
}

Boucle PowerShell Foreach et ForEach-Object

Pour traiter chaque élément d'un tableau ou d'une collection, vous pouvez utiliser les fonctions ForEach dans PowerShell.

Il existe deux types de fonctions foreach dans PowerShell, nous avonspour chaqueetPourEach-Objet. La différence entre les deux est queforeachchargera toute la collection dans la mémoire avant de commencer à traiter les données, ce quiForEach-Objecttraitera les données une par une. Cela rend ForEach-Object parfait pour diriger une autre fonction.

ForEach-Object a deux raccourcis que vous pouvez utiliser,ForEachet%. L'endroit où vous utilisez ForEach détermine quelle version des deux est utilisée.

$fruits = @('apple','pear','banana','lemon','lime','mango')

# Foreach - Loads all the fruits in the memory and process it
# Takes 21,4553 miliseconds
Foreach ($fruit in $fruits) {
    Write-Host $fruit;
}

#Shorthand for foreach
# Takes 14,3926 miliseconds
$fruits.foreach( {
    Write-Host $_;
}) 

# ForEach-Object 
# Takes 7,8812 miliseconds
$fruits | ForEach-Object {Write-Host $_}

# Shorthand for ForEach-Object
# Takes 7.3507 miliseconds
$fruits | ForEach {Write-Host $_}

# Also a Shorthand for ForEach-Object
# Takes 7,2982 miliseconds
$fruits | % {Write-Host $_}

Comme vous pouvez le voir, foreach est un peu plus lent dans cet exemple, mais la raison en est qu'il faut un peu de temps pour charger la collection dans la mémoire.

Si nous prenons un grand ensemble de données, avec 300 000 enregistrements par exemple, alors nous pouvons voir que foreach peut être beaucoup plus rapide queForEach-Object. Seule la consommation de mémoire serait un peu plus élevée pour chaque foreach.

$items = 0..300000

# Takes 180 ms to complete
(Measure-Command { foreach ($i in $items) { $i } }).TotalMilliseconds

# Takes 1300 ms to complete
(Measure-Command { $items | ForEach-Object { $_ } }).TotalMilliseconds

# Takes 850 ms to complete
(Measure-Command { $items.ForEach({ $i })}).TotalMilliseconds

Le moment où vous utilisez la fonction dépend vraiment de votre ensemble de données. Si vous devez traiter beaucoup de données, alorsForEach-Objectserait le meilleur choix pour éviter les problèmes de mémoire. Les petits ensembles de données peuvent parfaitement être traités avecForEach.

Un autre avantage deForEach-Objectest que vous pouvez diriger une autre applet de commande derrière, comme l'exporter au format CSV par exemple.

Blocs de script ForEach-Object

ForEach-Object vous permet d'utiliser des blocs de script qui peuvent être très utiles lorsque vous devez enregistrer le processus ou nettoyer une fois le script terminé.

$path = "C:\temp"
$totalSize = 0

Get-ChildItem $path | ForEach-Object -Begin {
        Write-Host "Processing folder $path"
    } -Process {
        $totalSize += ($_.length / 1kb)
    } -End {
        Write-host $totalSize "Kb"
    }

Powershell faire une boucle while

Le PowerShellFaire une boucle Whileest utilisé pour exécuter un scripttant que la condition est vraie ou remplie. Vous avez également leBoucle whileen PowerShell, sans la partie Do. Ils sont fondamentalement les mêmes, tous deux fonctionnent jusqu'à ce qu'une condition soit remplie.

Si vous exécutez les scripts ci-dessous, vous verrez qu'ils contiennent tous deux 10 excellents fichiers de test dans le dossier temporaire. Les deux courent aussi longtemps que$iest inférieur à 10.

$i = 0;
$path = "C:\temp"

# Do While loop
Do {
    # Do Something
    $newFile = "$path\dowhile_test_file_" + $i + ".txt";
    New-Item $newFile
    $i++;
}
While ($i -lt 10)

# While loop
$i = 0;
While ($i -lt 10) {
    # Do Something
    $newFile = "$path\while_test_file_" + $i + ".txt";
    New-Item $newFile
    $i++;
}

Mais il y aune grande différence entre les deux. Do While s'exécutera toujours au moins une fois, quelle que soit la condition que vous utilisez. La boucle while ne s'exécutera que lorsque la condition sera remplie.

Prenons l'exemple suivant, nous voulons exécuter le script, tant que$iest inférieur à 10. Mais nous avons mis le compteur à 15 pour commencer. Comme vous le verrez lorsque vous exécuterez le script, le Do While s'exécute une fois et le while ne s'exécute pas du tout.

$i = 15;

Do {
    Write-host "Do While $i is less then 15";
    $i++;
}
While ($i -lt 10)

$i = 15;
while ($i -lt 10)
{
    Write-host "While $i is less then 15";
    $i++;
}

Vous utilisez souvent une boucle do-while dans PowerShell lorsque vous attendez qu'une condition soit remplie, par exemple jusqu'à ce qu'un processus soit terminé ou comme dans l'exemple ci-dessous, jusqu'à ce que la connexion Internet soit hors ligne.

PowerShell ne continuera pas vers la ligne Write-Host tant que la condition while ne sera pas remplie. Donc dans cet exemple, nous testons la connexion Internet avec. Il retournera vrai lorsque nous aurons une connexion, et sinon, il retournera faux.

Do {
    Write-Host "Online"
    Start-Sleep 5
}
While (Test-Connection -ComputerName 8.8.8.8 -Quiet -Count 1)

Write-Host "Offline"

Création d'une boucle de veille dans PowerShell

Si vous souhaitez créer une boucle qui vérifie si un service est de nouveau en ligne ou si un fichier doit être créé, la meilleure option est d'utiliser une veille dans votre boucle.

Sans la partie veille, le script s'exécutera aussi vite que possible, ce qui peut atteindre 1 000 itérations par seconde ou plus.

Avec leDémarrer le sommeilcmdlet, nous pouvons initier une petite pause avant la prochaine itération :

Do {
    Write-Host "Online"
    Start-Sleep 5
}
While (Test-Connection -ComputerName 8.8.8.8 -Quiet -Count 1)

Write-Host "Offline"

Dans l'exemple ci-dessus, nous attendons 5 secondes avant de tester à nouveau la connexion à 8.8.8.8. Vous pouvez également utiliser des millisecondes au lieu de secondes pour la commande start-sleep.

Start-Sleep -Miliseconds 50

PowerShell Faire jusqu'à la boucle

Do Until est à peu près la même chose que Do While dans PowerShell. La seule différence réside dans l'état dans lequel ils fonctionnent.

• Faire pendantcontinue de courirtant que la condition est vraie. Lorsque la condition est fausse, il s'arrête.
• Faire jusqu'àcontinue de courirtant que la condition est fausse. Lorsque la condition devient vraie, elle s'arrête.

Do {
    Write-Host "Computer offline"
    Start-Sleep 5
}
Until (Test-Connection -ComputerName 'lab01-srv' -Quiet -Count 1)

Write-Host "Computer online"

Quand utiliser While ou Until dépend vraiment de ce que vous voulez faire. Sur cette base, vous pouvez dire que lorsque la condition de sortie doit être vraie, utilisez Jusqu'à. Si la condition de sortie est négative (fausse), vous devez utiliser While.

Arrêter une boucle Do While/Until

En PowerShell, nous pouvons utiliserCasserpour arrêter une boucle plus tôt. Il est préférable de limiter l’utilisation de sauts dans vos boucles car ils rendent votre code plus difficile à lire. Si vous avez bien structuré votre code, vous n’en avez vraiment pas besoin.

$i=0;
Do {
    Write-Host "Computer offline"
    Start-Sleep 1
    $i++;

    if ($i -eq 2) {
        Break
    }
}
Until (Test-Connection -ComputerName 'test' -Quiet -Count 1)

Utilisation de Continuer dans une boucle PowerShell

Une autre méthode utile que vous pouvez utiliser dans une boucle do-while/until dans PowerShell estContinuer. Avec Continue, vous pouvez arrêter le script dans le corps Do et passer à l'itération suivante de la boucle.

Cela peut être utile si vous avez un script volumineux dans un bloc Do et que vous souhaitez passer à l'élément suivant lorsqu'une certaine condition est remplie.

$servers = @('srv-lab01','srv-lab02','srv-lab03')

Foreach ($server in $servers) {
    
    if ((Test-Connection -ComputerName $server -Quiet -Count 1) -eq $false) {
        Write-warning "server $server offline"
        Continue
    }

    # Do stuff when server is online
}

Exemples de boucles PowerShell

Vous trouverez ci-dessous quelques exemples de boucles qui peuvent vous aider à créer vos propres boucles.

Boucle infinie PowerShell

Vous pouvez créer une boucle infinie dans PowerShell avec la fonction de boucle While. While continuera à fonctionner tant que la condition est vraie. Donc, pour créer une boucle infinie, nous pouvons simplement procéder comme suit :

While ($true) {
    # Do stuff forever
    Write-Host 'looping'

    # Use Break to exit the loop
    If ($condition -eq $true) {
        Break
    }
}

Pour quitter la boucle infinie, vous pouvez utiliser soitCtrl+Cou basé sur une condition avecCasser.

Boucle Powershell dans les fichiers

Pour parcourir les fichiers, nous allons utiliser la fonction foreach-object. Les fichiers sont des objets que nous pouvons obtenir avec l'applet de commande get-childitem, afin que nous puissions diriger l'objet foreach derrière lui. Une autre raison d’utiliser ForEach-Object au lieu de foreach est que nous ne savons pas à l’avance combien de fichiers nous allons traiter.

Foreach chargera toutes les données en mémoire, ce que nous ne voulons pas avec un ensemble de données inconnu.

$path = "C:\temp"
$csvItems = 0

Get-ChildItem $path | ForEach-Object {
    $_.Name;

    If ($_.Extension -eq '.csv') {
        $csvItems++;
    }
}

Write-host "Total CSV Files are $csvItems";

Si vous souhaitez également inclure le sous-dossier, vous pouvez utiliser l'option -recurse. Utilisez -filter pour obtenir uniquement les fichiers .csv par exemple.

Get-ChildItem $path -recurse -filter *.csv

Parcourez un fichier texte

Dans PowerShell, vous pouvez parcourir un fichier texte ligne par ligne. Cela peut être très utile si vous souhaitez par exemple lire automatiquement les fichiers journaux.

L'exemple ci-dessous fonctionne bien pour les petits fichiers, mais le problème est que Get-Content lira l'intégralité du fichier dans la mémoire.

$lineNr = 0

foreach($line in Get-Content c:\temp\import-log.txt) {
    if($line -match 'warning'){
        # Work here
        Write-warning "Warning found on line $lineNr :"
        Write-warning $line
    }

    $lineNr++;
}

Pour lire et traiter des fichiers plus volumineux avec PowerShell, vous pouvez également utiliser le lecteur de fichiers .Net :

foreach($line in [System.IO.File]::ReadLines("c:\temp\import-log.txt"))
{
       $line
}

Conclusion

J'espère que l'exemple vous a aidé à créer vos boucles PowerShell For, Foreach-Object, Do While et Until. Si vous avez des questions, déposez simplement un commentaire ci-dessous.