Maîtriser les boucles PowerShell : guide complet d’automatisation des systèmes

PowerShell est un interpréteur de ligne de commande et un langage de script multiplateforme conçu pour l’administration système. Combinables en scripts, les commandes PowerShell permettent d’automatiser les tâches répétitives et de traiter efficacement de gros jeux de données.

Les boucles, qui servent notamment à exécuter plusieurs fois un bloc de code de façon structurée, jouent un rôle important dans les scripts. Cet article explore en profondeur les types de boucles disponibles, y compris des scripts types correspondant à de nombreux cas d’utilisation courants, des méthodes pour bien gérer les erreurs, des stratégies pour améliorer l’efficacité des scripts, et de bonnes pratiques pour faciliter la lecture et la gestion.

De l’utilité des boucles dans PowerShell

En programmation, les boucles sont des structures de contrôle qui répètent l’exécution d’un même bloc de code jusqu’à la satisfaction de la condition spécifiée. Elles sont indispensables pour automatiser les tâches répétitives, traiter les collections de données et réaliser des opérations en bloc.

Vue d’ensemble des types de boucles dans PowerShell

PowerShell offre plusieurs types de boucles pour automatiser les tâches répétitives. Chacun a ses avantages propres qui le rendent adapté à différents scénarios. Chaque type est présenté ci-dessous :

For – la boucle For dans PowerShell convient parfaitement quand vous savez combien de fois vous voulez l’exécuter. Il ne vous reste qu’à définir une variable de compteur qui augmente d’une unité à chaque itération de la boucle.
ForEach – la boucle ForEach sert à effectuer une itération sur une collection d’éléments, par exemple ceux d’un tableau ou d’une liste. Il peut s’agir d’une itération dans une liste de noms qui inscrit chaque nom sur la console.
While – la boucle While dans PowerShell exécute un bloc de code jusqu’à ce que la condition spécifiée soit fausse, ce qui la rend utile dans les cas où le nombre d’itérations n’est pas connu. Vous pouvez par exemple exécuter votre code tant qu’un indicateur donné est sur « vrai ». Notez que la condition est vérifiée avant la première exécution : le bloc de code pourrait ne jamais s’exécuter.
Do-While – la boucle Do-While ressemble à celle de While, avec une différence majeure : le bloc de code s’exécute avant la première vérification de la condition, il s’exécutera donc au moins une fois.
Do-Until – la boucle Do-Until ressemble aussi à celle de While dans PowerShell, mais l’exécution se poursuit jusqu’à ce que la condition soit vraie.

Applications pratiques des boucles à l’automatisation dans l’entreprise

Les boucles jouent un rôle important dans des tâches comme le traitement des données, la production de rapports, la vérification des mises à jour logicielles et le contrôle de l’état des services. Une boucle peut, par exemple, effectuer en continu des tests ping à une liste de serveurs pour vérifier leur disponibilité et informer automatiquement l’équipe IT quand un serveur n’est plus joignable ou ne répond plus. Les boucles peuvent aussi servir pour les opérations en bloc, comme la création ou la modification de comptes utilisateurs dans Active Directory ou le traitement de fichiers journaux lors des audits de sécurité.

Boucle For

La boucle For dans PowerShell suit la syntaxe suivante :

for ([Initialization]; [Condition]; [Increment/Decrement]) {

  # Code to be executed in each iteration

}

Initialization – cette partie définit une variable de compteur et la valeur initiale. Elle s’exécute au début de la boucle.
Condition – cette partie précise une condition qui doit rester vraie pour que la boucle poursuive les itérations.
Increment/Decrement – cette partie s’exécute après chaque itération ; elle sert souvent à mettre à jour la valeur de la variable du compteur.

Dans cet exemple, la variable $i commence à 1, la boucle s’exécute aussi longtemps que $i est inférieure ou égale à 5, et $i augmente d’une unité à chaque itération :

for ($i = 1; $i -le 5; $i++) {

    Write-Host "Iteration: $i"

}

La boucle For sert souvent dans les cas suivants :

Itération dans un tableau – dans l’exemple ci-dessous d’une boucle For, PowerShell effectue une itération dans un tableau et inscrit chaque élément dans la console :

# Define an array of fruits

$fruits = @("apple", "banana", "cherry")

# Iterate through the array using a for loop

for ($i = 0; $i -lt $fruits.Length; $i++) {

    Write-Output $fruits[$i]

}

Comptage – voici comment utiliser une boucle For pour imprimer des nombres de 1 à 10 :

# Counting from 1 to 10

for ($i = 1; $i -le 10; $i++) {

    Write-Output $i

}

Création d’une table – le script suivant crée une table montrant comment multiplier par 5 :

# Generating a multiplication table for 5

$multiplicand = 5

for ($i = 1; $i -le 10; $i++) {

    $result = $multiplicand * $i

    Write-Output "$multiplicand * $i = $result"

}

Boucle ForEach

Une boucle ForEach exécute un bloc de code pour chaque élément de la collection. L’exemple simple ci-dessous crée un tableau avec trois prénoms ($names) et écrit chacun d’entre eux dans la console :

$names = "Alice", "Bob", "Charlie"

foreach ($name in $names) {

  # Code to execute for each item in the collection

  Write-Host "Hello, $name!"

}

Le script suivant récupère tous les fichiers texte d’un dossier et les enregistre dans ce même dossier sous un autre nom indiquant qu’il s’agit de copies de sauvegarde :

# Define the directory path and get all .txt files

$directory = "D:\Backup"

$files = Get-ChildItem -Path $directory -Filter "*.txt"

# Iterate over each file and rename it

foreach ($file in $files) {

    $newName = "$($file.BaseName)_backup$($file.Extension)"

    $newFullPath = Join-Path -Path $directory -ChildPath $newName

    # Rename the file

    Rename-Item -Path $file.FullName -NewName $newFullPath -Force

    Write-Host "Renamed: $($file.Name) ? $newName"

}

Boucles While, Do-While et Do-Until

Boucles While et Do-While

Les boucles While et Do-While répètent l’exécution d’un bloc de code tant qu’une condition spécifiée est vraie. Elles se révèlent utiles quand on ne sait pas en amont le nombre de fois qu’il faut exécuter une boucle.

Comme indiqué plus tôt, les boucles While et Do-While se différencient par le moment où la vérification de condition a lieu : dans PowerShell, la boucle While vérifie la condition avant d’exécuter le code, alors que la boucle Do-While s’exécute une fois avant cette vérification et exécute donc le code une fois même quand la condition est fausse dès le départ.

Par exemple, le script suivant utilise une boucle qui vérifie l’état du processus d’un bloc-notes toutes les 5 secondes jusqu’à ce que le processus soit fermé.

$processComplete = $false

do {

    Write-Host "Waiting for process to complete..."

    Start-Sleep -Seconds 5  # Simulate process waiting

    $processComplete = !(Get-Process -Name "notepad" -ErrorAction SilentlyContinue)

} while (-not $processComplete)

Write-Host "Process has completed!"

Boucle Do-Until

La boucle Do-Until ressemble à Do-While ; mais alors que la boucle Do-While continue tant que la condition est vraie, Do-Until se poursuit tant que la condition est fausse. Ainsi, Do-Until est plus efficace quand on attend qu’un événement se produise.

Par exemple, le script suivant utilise une boucle Do-Until pour attendre qu’un fichier soit actualisé. Toutes les 5 secondes il compare l’heure de la dernière écriture avec la variable $lastModified ; dès que ces valeurs sont différentes, il imprime un message indiquant que le fichier a été mis à jour.

# Path of the file to monitor

$filePath = "D:\Backup\myfile_backup.txt"

# Get the initial last write time of the file

$lastModified = (Get-Item $filePath).LastWriteTime

do {

    Write-Host "Waiting for file update..."

    Start-Sleep -Seconds 5

# Get the current write time and compare the last write time

} until ((Get-Item $filePath).LastWriteTime -ne $lastModified)

Write-Host "File has been updated!"

Techniques avancées de boucle pour automatisations puissantes

Combiner les boucles avec des instructions conditionnelles If-Else

Les instructions If et Else servent à exécuter conditionnellement du code en fonction de conditions définies dans la boucle. Par exemple, le code suivant fait une itération de 0 à 9 et indique pour chacune si le chiffre est pair ou impair :

# Print even and odd numbers in a range

for ($i = 0; $i -lt 10; $i++) {

    if ($i % 2 -eq 0) {

        Write-Output "$i is even"

    } else {

        Write-Output "$i is odd"

    }

}

Sortir précocement d’une boucle avec Break

L’instruction Break sert à sortir d’une boucle quand la condition spécifiée est vraie ; le reste du code de la boucle n’est pas exécuté.

Dans l’exemple suivant, la boucle For doit faire une itération de 1 à 19 ; toutefois, si un multiple de 6 est trouvé, elle imprime cet élément et arrête la boucle :

# Find the first multiple of 6 in a range

for ($i = 1; $i -lt 20; $i++) {

    if ($i % 6 -eq 0) {

        Write-Output "First multiple of 6 is found: $i"

        break

    }

}

Sauter les itérations inutiles avec Continue

L’instruction Continue ignore le reste du code à l’intérieur de l’itération actuelle de la boucle et passe à la prochaine itération. L’exemple suivant réalise une itération des chiffres 1 à 9 et imprime chacun d’entre eux sauf les multiples de 4 :

# Print all numbers except multiples of 4

for ($i = 1; $i -lt 10; $i++) {

    if ($i % 4 -eq 0) {

        continue

    }

    Write-Output $i

}

Gestion de la mémoire dans les boucles

Réduire l’utilisation de la mémoire pour chaque cmdlet ForEach-Object

Si la boucle ForEach peut servir à réaliser une itération dans l’ensemble des objets d’une collection, mieux vaut parfois utiliser la cmdlet ForEach-Object :

La boucle ForEach réalise une itération en parcourant une collection stockée en mémoire dans une variable. Elle convient dans les cas où une collection est déjà en mémoire et où il faut un résultat rapide.
La cmdlet ForEach-object traite successivement les éléments un par un, ce qui réduit considérablement la consommation de mémoire. Elle est particulièrement utile pour traiter individuellement chaque ligne de gros fichiers de journalisation.

Le script ci-dessous utilise la cmdlet ForEach-Object pour localiser des entrées du journal de l’observateur d’événements avec un ID d’événement spécifique et les stocker dans un fichier texte :

# Define the log name and filter criteria

$logName = "Application"

$eventLevel = "Error"  # Filter for logs with the level "Error"

$eventID = 1000        # Filter for logs with the event ID 1000

# Get the Event Viewer logs and filter using ForEach-Object to reduce memory usage

Get-WinEvent -LogName $logName | ForEach-Object {

    # Check if the log entry matches the filter criteria

    if ($_.LevelDisplayName -eq $eventLevel -and $_.Id -eq $eventID) {

        # Output the filtered log entry

        $_

    }

} | Out-File -FilePath "D:\Backup\eventviewer_logs.txt"

Boucles imbriquées pour les manipulations complexes de données

PowerShell Permet d’imbriquer une boucle For à l’intérieur d’une autre. Vous pouvez utiliser cette technique par exemple pour :

manipuler efficacement des données multidimensionnelles comme des tableaux de tableaux ou des matrices ;
traiter des structures hiérarchisées comme JSON, XML et des tables de hachage imbriquées ;
réaliser des tâches répétitives sur des données structurées comme traiter des fichiers journaux par lots.

Par exemple, pour créer une structure de données à plusieurs niveaux

Le script suivant utilise des boucles imbriquées For pour créer une table de multiplication :

$size = 5  # Define table size

for ($i = 1; $i -le $size; $i++) {  # Outer loop for rows

    for ($j = 1; $j -le $size; $j++) {  # Inner loop for columns

        Write-Host -NoNewline "$($i * $j)`t"

    }

    Write-Host  # Newline after each row

}

Par exemple, pour manipuler des données hiérarchisées (tables de hachage imbriquées)

D’autres types de boucles, notamment la boucle ForEach, peuvent aussi être imbriquées comme dans le script ci-dessous pour manipuler des données hiérarchisées :

$users = @{

    "Alice"   = @("Admin", "Editor")

    "Bob"     = @("User")

    "Charlie" = @("Moderator", "Editor", "User")

}

foreach ($user in $users.Keys) {  # Outer loop iterates over usernames

    Write-Host "User: $user"

    foreach ($role in $users[$user]) {  # Inner loop iterates over roles

        Write-Host "  - Role: $role"

    }

}

Gestion des erreurs et débogage dans les boucles

Importance de Try-Catch pour l’exécution robuste des scripts

La gestion des erreurs est indispensable quand un script peut se trouver en conditions d’échec, par exemple en cas de fichier introuvable, d’autorisation refusée ou de problème réseau. Une bonne gestion des erreurs avec des blocs Try-Catch garantit que votre script peut gérer de telles exceptions avec adresse, en affichant des messages d’erreur utiles, et continuer de s’exécuter ou s’interrompre en toute sécurité.

Le script suivant d’actualisation de fichiers utilise Try-Catch pour traiter fluidement les cas de fichier introuvable ou de connexion au serveur impossible :

$sourceFile = "D:\Office\project\myfile.txt"  # The file to be updated

$serverName = "google.com"      # The server to check

# 1. Find the source file (with error handling)

try {

    if (!(Test-Path $sourceFile)) {

        throw "Source file not found: $sourceFile" # Throw custom error

    }

    Write-Host "Source file found: $sourceFile"

} catch {

    Write-Error $_

    exit 1 # Exit the script if the file isn't found

}

# 2. Check network connectivity (with error handling)

$networkStatus = $null # Initialize network status variable

try {

    if (Test-NetConnection -ComputerName $serverName -ErrorAction Stop) {

        Write-Host "Ping to $serverName successful."

        $networkStatus = "Connected"

    } else {

        Write-Warning "Ping to $serverName failed."

        $networkStatus = "Failed"

    }

} catch {

    Write-Error "Error checking network connection: $_"

    $networkStatus = "Error: $($_.Exception.Message)" # Store error message

}

# 3. Edit the file with the results (with error handling)

try {

    $content = Get-Content $sourceFile

    $newContent = "$content`nNetwork Check Result: $networkStatus" # Add a newline

    Set-Content -Path $sourceFile -Value $newContent -ErrorAction Stop

    Write-Host "File '$sourceFile' updated successfully."

    Write-Host "New content:"

    Get-Content $sourceFile #Print the new content

} catch {

    Write-Error "Error updating file: $_"

}

Write-Host "Script complete."

Conseils d’optimisation des performances pour les boucles PowerShell

Les stratégies suivantes peuvent réduire la durée d’exécution et la consommation de ressources lors de l’utilisation de boucles For.

Réduire les itérations inutiles

Pour diminuer le nombre d’itérations non nécessaires de la boucle, filtrez les données avant d’entrer dans celle-ci et utilisez Break et Continue pour en sortir quand une condition devient vraie.

Éviter les calculs inutiles à l’intérieur des boucles

Une bonne pratique incontournable pour améliorer l’efficacité des boucles dans PowerShell est d’éviter tout calcul non nécessaire à l’intérieur. À la place, calculez les valeurs hors de la boucle dès que c’est possible. Par exemple, une fonction ou commande qui récupère des données restant les mêmes pendant l’itération devrait être exécutée une seule fois, avant l’entrée dans la boucle.

Améliorer la lisibilité de la boucle et sa maintenabilité

Pour faciliter la compréhension et la maintenance de vos boucles, assurez-vous d’utiliser :

des noms de variables clairs et des indentations homogènes ;
une conception modulaire pour décomposer une logique complexe en fonctions distinctes ;
les boucles For quand le nombre d’itérations est connu et les While pour répéter selon une condition ;
des boucles concises et aucune imbrication inutile.

Réduire au minimum la sortie sur la console

Évitez d’utiliser des instructions Write-Host non nécessaires.

Utiliser efficacement les pipelines pour réduire les traitements des scripts

Quand vous traitez de gros ensembles de données, utilisez des pipelines pour faire passer les données d’une cmdlet à la suivante. Cette stratégie évite de stocker des résultats intermédiaires volumineux en mémoire et réduit largement les traitements.

Faire bon usage des boucles ForEach et de la cmdlet ForEach-Object

Comme nous l’avons déjà vu, la cmdlet ForEach-Object est moins gourmande en mémoire que la boucle ForEach. Envisagez de modifier vos scripts pour utiliser ForEach-Object le cas échéant.

Par exemple, voici un script qui fait appel à une boucle ForEach pour copier des fichiers d’un dossier à un autre, puis un autre qui y arrive avec la cmdlet ForEach-Object.

Utiliser une boucle ForEach

# Define the source and destination directories

$directoryPath = "D:\Office\Backup"

$destinationDirectory = "D:\Office\myfolder"

# Ensure the destination directory exists

if (-not (Test-Path -Path $destinationDirectory)) {

    New-Item -ItemType Directory -Path $destinationDirectory

}

# Get all files in the directory

$files = Get-ChildItem -Path $directoryPath

# Process each file

foreach ($file in $files) {

    try {

        # Read content and write to another file

        $content = Get-Content -Path $file.FullName

        $newFileName = Join-Path -Path $destinationDirectory -ChildPath $file.Name

        $content | Out-File -FilePath $newFileName

        Write-Output "Processed file: $($file.FullName)"

    } catch {

        Write-Output "Error processing file: $($file.FullName). $_"

    }

}

Write-Output "File processing completed."

Using the ForEach-Object Cmdlet

# Define the source and destination directories

$directoryPath = "D:\Office\Backup"

$destinationDirectory = "D:\Office\myfolder"

# Ensure the destination directory exists

if (-not (Test-Path -Path $destinationDirectory)) {

    New-Item -ItemType Directory -Path $destinationDirectory

}

# Process each file using the pipeline

Get-ChildItem -Path $directoryPath | ForEach-Object {

    try {

        # Read content and write to another file

        $content = Get-Content -Path $_.FullName

        $newFileName = Join-Path -Path $destinationDirectory -ChildPath $_.Name

        $content | Out-File -FilePath $newFileName

        Write-Output "Processed file: $($_.FullName)"

    } catch {

        Write-Output "Error processing file: $($_.FullName). $_"

    }

}

Write-Output "File processing completed."

Applications des boucles PowerShell sur le terrain

Automatisation des tâches d’administration système

Les administrateurs peuvent utiliser des boucles pour effectuer une action particulière sur chaque objet d’une collection, par exemple sur un ensemble de fichiers, de dossiers ou de comptes utilisateurs. Par exemple, les boucles peuvent servir à appliquer des correctifs de sécurité sur tous les serveurs d’un réseau ; surveiller les ressources systèmes et redémarrer les services ou envoyer des notifications le cas échéant ; et modifier ou supprimer des objets Active Directory.

Vérification automatique des serveurs pour chaque cmdlet ForEach-Object

Le script suivant rend compte si les serveurs sont en ligne ou pas :

$servers = @("lhehost9", "lhehost10", "lhehost11")

$servers | ForEach-Object {

# check if the server is reachable

    $status = Test-Connection -ComputerName $_ -Count 2 -Quiet

    if ($status) {

        Write-Output "$_ is online"

    } else {

        Write-Output "$_ is offline"

    }

}

Programmation de tâches système avec des boucles While

Ce script surveille le statut du service spouleur et le redémarre lorsque nécessaire :

$serviceName = "Spooler"

while ($true) {

    $service = Get-Service -Name $serviceName

    if ($service.Status -ne "Running") {

        Write-Output "$(Get-Date): $serviceName is not running. Restarting..."

        Restart-Service -Name $serviceName -Force

    }

    else {

        Write-Output "$(Get-Date): $serviceName is running normally."

    }

    Start-Sleep -Seconds 30  # Check every 30 seconds

}

Traitement de données dans les environnements d’entreprise

Dans les environnements d’entreprise, le traitement des données implique souvent de gros volumes de données issues de différentes sources – bases de données, fichiers journaux, ressources système… Les boucles peuvent effectuer des itérations sur ces jeux de données volumineux pour simplifier le reporting, analyser les journaux d’événements et filtrer les éléments non pertinents.

Automatiser les rapports avec des boucles

Le script suivant crée un fichier .csv de tous les utilisateurs Active Directory dans une unité organisationnelle donnée :

$users = Get-ADUser -SearchBase "OU=Engineering,OU=US Staff,DC=ca,DC=lo" -Filter * -Property Name, SamAccountName, EmailAddress 

$reportPath = "C:\Reports\ADUsersReport.csv"

$users | ForEach-Object {

    "$($_.Name),$($_.SamAccountName),$($_.EmailAddress)" | Out-File -Append -FilePath $reportPath

}

Write-Output "Report generated at $reportPath"

Filtrer des journaux avec des boucles

Ce script récupère les 1 000 entrées les plus récentes d’un journal système pour créer un fichier .csv énumérant les événements critiques :

$logName = "System"

$eventLimit = 1000

$outputFile = "C:\Reports\EventLogs.csv"

# Ensure the log file has a header

"TimeCreated,EventID,Provider,Message" | Set-Content -Path $outputFile

# Get the latest 1000 events and filter for Critical and Error events

$events = Get-WinEvent -LogName $logName -MaxEvents $eventLimit | Where-Object { $_.Level -le 2 }

# Process each event safely

$events | ForEach-Object {

    $eventTime = $_.TimeCreated

    $eventID = $_.Id

    $provider = $_.ProviderName

    $message = $_.Message -replace "`r`n", " "  # Remove newlines for better CSV formatting

    # Handle missing or null messages

    if ([string]::IsNullOrEmpty($message)) {

        $message = "No description available"

    }

    # Append to file

    "$eventTime,$eventID,$provider,$message" | Add-Content -Path $outputFile

}

Write-Output "Filtered logs saved at $outputFile"

Boucle PowerShell pour DevOps et les opérations cloud
Automatisation à base de boucles pour la gestion de l’infrastructure cloud

Dans les environnements DevOps et cloud modernes, les boucles PowerShell peuvent jouer un rôle important pour gérer et faire évoluer l’infrastructure. Les administrateurs peuvent automatiser les tâches répétitives comme la mise à jour des machines virtuelles et des conteneurs Docker et l’application des correctifs de sécurité dans l’ensemble de l’infrastructure cloud. Les boucles peuvent effectuer des itérations des machines virtuelles (VM) d’une infrastructure cloud, comme un groupe de ressources Azure, pour en connaître l’état d’intégrité et pour lancer une VM qui se serait inopinément arrêtée. De même dans les environnements conteneurisés les boucles aident à automatiser les tâches récupérer des images Docker actualisées, relancer des conteneurs arrêtés et garantir la disponibilité des services.

Passer en revue les machines virtuelles ou les conteneurs pour des actualisations ou vérifications

Le script suivant utilise une boucle ForEach pour connaître l’état de chaque conteneurs Docker, extraire l’ID et le nom de chacun d’entre eux, et afficher l’état sur la console :

# Ensure Docker is installed and running

# Get a list of all running containers

$containers = docker ps --format "{{.ID}} {{.Names}}"

# Loop through each container and check its status

foreach ($container in $containers) {

    $containerId, $containerName = $container -split ' '

    Write-Output "Checking status for container: $containerName ($containerId)"

    # Get the status of the container

    $status = docker inspect --format "{{.State.Status}}" $containerId

    Write-Output "Status of container $containerName: $status"

}

Write-Output "All container statuses have been checked."

Conclusion

PowerShell offre de nombreux types de de boucles pour créer des scripts pratiques dans des cas d’utilisation très divers, notamment les boucles For, ForEach, While, Do-While et Do-Until. Les blocs Try-Catch et les instructions Break-Continue permettent de gérer commodément les conditions d’erreur et d’améliorer l’efficacité des scripts. Pour affûter vos compétences, jouez avec les exemples de codes donnés ici.

Quelle est la différence entre ForEach and ForEach-Object ?

La boucle ForEach sert à effectuer une itération dans une collection de données en mémoire, alors que la cmdlet ForEach-Object permet de traiter les données issues d’un pipeline. ForEach-Object est peu gourmand en mémoire, car elle traite les éléments un à un à mesure que ceux-ci passent dans le pipeline, alors que les performances de ForEach sont plus rapides pour les ensembles de données restreints.

Comment optimiser les boucles PowerShell pour les grands ensembles de données ?

Pour le traitement de grands ensembles de données, vous pouvez réduire au minimum l’utilisation de la mémoire et le temps d’exécution en filtrant les données avant d’entrer dans la boucle à l’aide de la cmdlet ForEach-Object plutôt que de la boucle ForEach et en précalculant les valeurs hors des boucles pour éviter les opérations redondantes à chaque itération.

Peut-on sortir d’une boucle PowerShell avant la fin ?

Oui, il est possible de sortir d’une boucle ou juste de l’itération courante d’une boucle à l’aide des instructions Break et Continue. L’instruction Break interrompt immédiatement toute la boucle et transfère le contrôle à l’instruction suivante, alors que l’instruction Continue saute les instructions restant dans l’itération actuelle et passe à l’itération suivante.

Quel est le meilleur moyen de déboguer les boucles dans PowerShell ?

Un bon moyen de déboguer les boucles dans PowerShell est d’utiliser Write-Host, Write-Debug ou Write-Output pour imprimer les valeurs des variables à chaque itération.