Les boucles For

I. Présentation

En PowerShell, il y a plusieurs façons d'effectuer des boucles, et chaque type de boucle a ses propres caractéristiques. Dans le chapitre à suivre, nous allons nous concentrer sur les boucles "For" en PowerShell, qui sont particulièrement utiles pour effectuer une action un nombre défini de fois.

La boucle "For" est un grand classique des différents langages de scripting et de programmation. Différents exemples seront intégrés à ce chapitre pour vous aider à vous familiariser avec le principe des boucles "For".

II. Qu'est-ce qu'une boucle en scripting ?

Une boucle en scripting et en programmation permet de répéter un bloc de code dans le but d'effectuer des opérations identiques sur un ensemble de valeurs. Ce bloc de code va se répéter un certain nombre de fois, en fonction de ce que l'on appelle une condition de répétition.

L'objectif d'une boucle est de simplifier le code en évitant la redondance. Au lieu d'écrire le même code encore et encore, vous pouvez simplement le placer dans une boucle qui va l'exécuter autant de fois que nécessaire, et ce, de façon dynamique (pour parcourir l'ensemble d'une collection, par exemple).

III. Comment fonctionne une boucle For ?

L'objectif d'une boucle "For" est d'exécuter X fois un bloc d'instructions, où le nombre d'exécutions dépend de l'état de la condition testée.

En PowerShell, la boucle "For" s'appuie sur la syntaxe suivante :

For(<état initial>;<condition de répétition>;<incrémentation>)
{
  <Si la condition est vraie, on exécute ce bloc d'instructions>
}

<Si la condition est fausse, la boucle for se termine et le script continue...>

Lorsque nous utilisons une boucle "For", nous suivons la logique suivante : nous indiquons une valeur de départ (état initial), une valeur cible dans la condition de répétition (par exemple, la valeur 10) et nous incrémentons la valeur à chaque tour de boucle (à chaque itération) : nous pouvons incrémenter de 1, de 2, de 10, etc... selon nos besoins.

IV. Exemples "For" en PowerShell

Pour bien comprendre, c'est toujours mieux d'avoir des exemples, commençons par un premier exemple très simple. Nous verrons ensuite un autre exemple avec une boucle "dynamique" et un troisième exemple avec deux conditions.

• Boucle "For" de base

Pour ce premier exemple, nous allons partir du principe que l'on part de la valeur "1", et que, tant que la valeur est inférieure à 10, nous exécutons le bloc d'instruction de la boucle "For", en incrémentant de +1 à chaque itération (c'est-à-dire à chaque tour de boucle).

Note : Affecter la valeur "0..10" à une variable sert à créer un tableau de valeurs, de 0 à 10.

Ce qui donne :

$valeur = 0..10
For($i=0 ; $i -lt 10 ; $i++) 
{ 
   Write-Output "La valeur est $($valeur[$i])" 
}

Nous obtenons le résultat suivant :

Cela signifie qu'après la ligne "La valeur est 9", l'exécution du script va se poursuivre. La phrase "La valeur est 10" n'est pas affichée, car nous avons utilisé la condition de répétition "$i -lt 10", donc $i doit être strictement inférieur à 10 pour que le code dans la boucle For soit exécuté.

• Boucle "For" basée sur un nombre d'éléments

Imaginons que nous disposions d'un tableau de chaînes de caractères (string) et que nous souhaitons exécuter une action sur chaque valeur du tableau, sans connaître à l'avance le nombre d'éléments du tableau. Nous pouvons utiliser la propriété "Length" pour calculer la taille du tableau (le nombre d'éléments dans ce tableau).

Nous allons définir la variable "$langages" et lui attribuer des valeurs (cela pourrait être dynamique). Grâce à "$langages.Length", nous allons pouvoir faire une boucle qui traite l'ensemble des éléments du tableau. C'est ce que l'on fait habituellement (et plus simplement) avec une boucle "ForEach", que nous allons étudier dans un prochain chapitre, mais nous pouvons le faire aussi avec une simple boucle "Fo"r, d'où cet exemple.

Ce qui donne :

$langages = @("PowerShell","Python","PHP","JavaScript","C-Sharp")

For($i=0 ; $i -lt $langages.Length ; $i++) 
{ 
   Write-Output "Le meilleur langage de programmation est $($langages[$i])"
}

Nous obtenons le résultat suivant :

• Boucle "For" à conditions multiples

Au sein d'une boucle "For", nous utilisons généralement la variable "$i" pour gérer l'initialisation et l'incrémentation (nous pourrions utiliser un autre nom de variable). Si besoin, nous pouvons utiliser deux conditions afin de créer une boucle "For" à conditions multiples. Pour cet exemple, nous prendrons "$i" et "$j".

Pour passer d'une variable à deux variables, et donc avoir deux conditions de répétition, nous allons devoir faire évoluer la syntaxe de notre boucle "For".

$valeur = 0..10

For(($i = 0), ($j = 0); $i -lt 10 -and $j -lt 10; $i++,$j++)
{
   Write-Output "Les valeurs sont : i = $($valeur[$i]) - j = $($valeur[$j])"
}

Si l'on reprend les deux précédents exemples, avec la valeur de 1 à 10 et le tableau de langages, cela donne :

$valeur = 0..10
$langages = @("PowerShell","Python","PHP","JavaScript","C-Sharp")

For(($i = 0), ($j = 0); $i -lt 10 -and $j -lt $langages.Length; $i++,$j++)
{
  Write-Output "$($valeur[$i]) - $($langages[$i])"
}

Dès que nous arrivons à la fin du tableau "$langages", nous sortons de la boucle "For" car il faut que "$i" soit inférieur à 10 ce qui est toujours le cas ET que "$j" soit inférieur à la longueur du tableau, ce qui n'est plus le cas, car nous sommes au bout du tableau.

Si nous voulons que ça continue jusqu'à la fin de "$i" et "$j", il faut remplacer le "-and" par "-or" (remplacer "et" par "ou") pour que ça continue tant que l'une ou l'autre des conditions soient vraies. Le résultat sera alors différent :

V. Conclusion

Les boucles "For" sont simples à utiliser et peuvent s'avérer pratique dans vos scripts, mais n'oubliez pas non plus d'utiliser le bon type de boucle en fonction des circonstances : une boucle "Do-While", "Do-Until" ou encore un "ForEach". Vous serez plus à même de le faire lorsque nous aurons étudié les différents types de boucles, et après avoir mis en pratique ces boucles au sein de scripts PowerShell.