Les bases de Powershell - 1ère partie

Création — Nicolas THOREZ 2019/02/20 20:43

Je vais juste récapituler ici certaines bases très utiles dans la plupart des scripts.

Les opérateurs logiques permettent de comparer deux variables au moyen d'une opération et de renvoyer le résultat, généralement sous la forme d'un booléen $true ou $false.

• Référence : Microsoft

1 -eq 1
$true
1 -eq a
$false

1 -ne 1
$false
1 -ne a
$true

2 -gt 1
$true
2 -gt 2
$false

2 -ge 1
$true
2 -ge 2
$true

1 -lt 2
$true
2 -lt 2
$false

1 -le 2
$true
2 -le 2
$true

A noter que les vérification ne sont pas sensible à la casse par défaut. Ainsi A -eq a renvoie la valeur $true. Pour rendre ces opérateur sensible à la casse, il suffit d'insérer un c après le - (par ex: -eq devient -ceq). De plus, on peut forcer l'insensibilité à la casse en insérant un i après le - (par ex: -eq devient -ieq).

"Nicolas" -like "Nico*"
$true

"Nicolas" -notlike "Jean*"
$true

"Nicolas","Jean","Marc" -match "Nico"
$true

"Nicolas","Jean","Marc" -notmatch "Albert"
$true

Comme pour les opérateurs d'égalité, ces opérateurs sont par défaut insensibles à la casse. Les modificateurs c et i peuvent être utilisés. Les opérateurs de type match peut utiliser les expressions régulières dans leur recherche de correspondances (voir Les expressions régulières (regex)).

Les conditions permettent de réaliser une action selon le résultat d'une opération logique.

• Référence : Micorsoft

If effectue un test. Si le résultat est $true alors un code est exécuté. En option, on peut indiquer un comportement particulier en cas de résultat $false :

• ElseIf : Effectue un nouveau test et permet d'exécuter un code si ce dernier est $true. On peut enchaîner autant de ElseIf que l'on veut.
• Else : Exécute un code si le résultat du test If est $false. Il ne peut y avoir qu'un seul Else et il sera placé à la fin du bloc If.

If ($Var -eq 1)                                      # On vérifie si la valeur de $Var est égale à 1 
    {                                                # On ouvre le bloc de code pour un résultat $true de If
        Write-Host '$Var = 1'                        # On écrit dans la console : $Var = 1
    }                                                # On ferme le bloc
ElseIf ($Var -eq 2)                                  # Si le test de IF est $false, on peut faire un autre test avec ElseIF
    {                                                # On ouvre le bloc de code pour un résultat $true de ElseIf
        Write-Host '$Var = 2'                        # On écrit dans la console : $Var = 2
    }                                                # On ferme le bloc du ElseIF
Else                                                 # On peut finir avec un Else qui sera exécuté si tous les tests précédents sont $false
    {                                                # On ouvre le bloc Else
        Write-Host '$Var différent de 1 et 2'        # On écrit dans la console encore une fois
    }                                                # On ferme le bloc

• Référence : Microsoft

Switch permet d'exécuter un code selon le résultat d'un test. On pourra indiquer autant de résultats attendus que l'on souhaite et on terminera le bloc avec l'instruction default correspondant au code à exécuter si le résultat du test ne correspond à aucune des valeurs précédemment indiquées.

$Entry = Read-Host "Entrez votre âge"                # On demande à l'utilisateur d'écrire son âge qu'on stocke dans $Entry
Switch ($Entry)                                      # On teste la valeur de $Entry. On pourrait aussi faire une opération logique
    {                                                # On ouvre le bloc d'exécution de Switch
        1        { Write-Host "Age: 1" }             # Si c'est 1, on écrit Age: 1
        2        { Write-Host "Age: 2" }             # Si c'est 2, on écrit Age: 2
        99       { Write-Host "Age: 99" }            # Si c'est 99, on écrit Age: 99
        default  { Write-Host "Je sais pas" }        # Sinon, on écrit Je sais pas
    }                                                # On ferme le bloc

Switch est par défaut insensible à la casse. Ainsi, a sera traité de la même manière que A. Si les deux résultats sont dans la liste des résultats attendus alors le traitement sera effectué sur chaque entrée de la liste. Pour éviter ce fonctionnement ou pour rendre Switch sensible à la casse on peut ajouter le paramètre -CaseSensitive.

$Letter = "a"
Switch ($Letter)
{
    "a" { Write-Host "Lettre a" }
    "A" { Write-Host "Lettre A" }
}

# Retour
Lettre a
Lettre A

$Letter = "a"
Switch -CaseSensitive ($Letter)
{
    "a" { Write-Host "Lettre a" }
    "A" { Write-Host "Lettre A" }
}

# Retour
Lettre a

Les boucles permettent de répéter un code un certain nombre de fois.

• Référence : Microsoft

ForEach-Object (ou son alias ForEach) permet d'exécuter un code sur chaque élément d'un ensemble d'éléments.

$Serie = 1,2,3,4,5                             # On crée une variable contenant les valeurs 1, 2, 3, 4 et 5
ForEach ($Chiffre in $Serie)                   # On stockera dans $Chiffre une valeur de $Serie de la première à la dernière
    {                                          # On ouvre le bloc
        Write-Host $Chiffre                    # On écrit la valeur de $Chiffre dans la console
    }                                          # On ferme le bloc
    
# Cette boucle va nous renvoyer le résultat suivant :
1
2
3
4
5

• Référence : Microsoft

Dans cette exemple, on crée une boucle qui va attendre 30 fois 1 seconde soit théoriquement un total de 30 secondes :

(Measure-Command { 1..30 | ForEach-Object { Start-Sleep -Seconds 1 } }).Seconds
10

En activant le paramètre -Parallel :

(Measure-Command { 1..30 | ForEach-Object { Start-Sleep -Seconds 1 } }).Seconds
6

La commande n'a mis que 6 secondes car la parallélisation a traitée 5 commandes (valeur par défaut) en concurrence. Le paramètre -ThrottleLimit permet de définir le nombre de commandes concurrentes :

(Measure-Command { 1..30 | ForEach-Object { Start-Sleep -Seconds 1 } -ThrottleLimit 10 }).Seconds
3

La parallélisation permet d'améliorer le temps d'exécution des scripts mais attention tout de même. Chaque concurrent va créer son propre espace de travail (runspace), traiter la commande et le clore. Dans certains cas, ces multiples actions d'ouvertures et fermetures sont plus longues que le traitement, ce qui entraîne une augmentation global de la durée d'exécution du script. Par exemple :

(Measure-Command { Get-Process | ForEach-Object { Write-Host $_.Name } }).Milliseconds
91
(Measure-Command { Get-Process | ForEach-Object -Parallel { Write-Host $_.Name } }).Milliseconds
995

• Référence : Microsoft

For nécessite une variable qui servira de compteur. Un test sera réalisé sur ce compteur et un code sera exécuté si ce test est $true. Une fois le code exécuté, le compteur est incrémenté selon le pas indiqué. A la place du pas, on peut indiquer un nombre maximal d'itération.

For ( $i=0 ; $i -lt 5 ; $i++ )             # On part de 0, on teste si $i est inférieur à 5 et à chaque boucle on ajoute 1 à $i
    {                                      # On ouvre le bloc
        Write-Host $i                      # On écrit la valeur de $i
    }                                      # On ferme le bloc
    
# La boucle suivante nous renvoie les résultats suivants :
0
1
2
3
4

• Référence : Microsoft

Do va exécuter un code puis effectuer un test. Selon le résultat de ce test, il continuera ou arrêtera la boucle. Le test est introduit par les commande Until ou While.

• Until : on continue jusqu'à ce que le résultat du test soit $true.
• While : on continue tant que le résultat du test est $true.

$i = 0                                                  # On crée une variable dont la valeur est 0
Do                                                      # On se prépare à faire une boucle
    {                                                   # On ouvre le bloc
        Write-Host $i                                   # On écrit la valeur de $i
        $i++                                            # On ajoute 1 à $i (Pour éviter les boucles infinies)
    }                                                   # On ferme le bloc
Until ($i -eq 4)                                        # On teste si $i est égal à 4

# La boucle ci-dessus nous renvoie les résultat suivant :
0
1
2
3

$i = 0                                                  # On crée une variable dont la valeur est 0
Do                                                      # On se prépare à faire une boucle
    {                                                   # On ouvre le bloc
        Write-Host $i                                   # On écrit la valeur de $i
        $i++                                            # On ajoute 1 à $i (Pour éviter les boucles infinies)
    }                                                   # On ferme le bloc
While ($i -eq 4)                                        # On teste si $i est égal à 4

# En changeant Until par While, on obtient :
0

# La boucle avec Until s'est arrêté à 3 car lorsque $i a eu la valeur 4, le test a renvoyé un $true.
#
# Dans le cas de While, la boucle n'a exécuté que la première itération car le test "$i est-il égal à 4 ?" a renvoyé un $false
# $i étant égal à 1, à ce moment là.

• Référence : Microsoft

While (l'instruction seule et non celle qui termine l'instruction Do) est différent de Do du fait qu'elle n'exécute le code qu'après avoir vérifier que son test soit vrai. Ainsi Do effectue au moins une itération alors que While peut n'en effectuer aucune.

$i = 0                                                  # On crée une variable dont la valeur est 0
While ($i -ne 4)                                        # On teste si $i est différent de 4
    {                                                   # On ouvre le bloc
        Write-Host $i                                   # On écrit la valeur de $i
        $i++                                            # On ajoute 1 à $i (Pour éviter les boucles infinies)
    }                                                   # On ferme le bloc

# La boucle suivante renvoie :
0
1
2
3 

# Si on avait remplacé -ne par -eq dans le test, la console n'aurait rien affiché car la vérification 
# du test aurait renvoyé $false