Les scripts sous PowerShell

Un script PowerShell est un fichier texte contenant une série de commandes PowerShell. Les scripts sont utilisés pour automatiser des tâches et peuvent être exécutés dans l'environnement PowerShell.

L'éditeur de scripts PowerShell

PowerShell ISE (Integrated Scripting Environment) est un éditeur de scripts intégré à PowerShell, conçu pour faciliter l'écriture, le test et le débogage de scripts PowerShell. Il offre une interface graphique conviviale avec des fonctionnalités telles que la coloration syntaxique, l'auto-complétion, et un débogueur intégré. ISE permet également d'exécuter des scripts ligne par ligne, ce qui est utile pour tester des commandes avant de les inclure dans un script complet.

Pour ouvrir le volet de l'éditeur de scripts dans PowerShell ISE, vous pouvez utiliser la commande ise dans la console PowerShell. Cela ouvrira l'interface graphique où vous pourrez créer et modifier vos scripts.

Écrire un script PowerShell

Un script PowerShell est un fichier texte contenant une série de commandes PowerShell. Les scripts sont généralement enregistrés avec l'extension .ps1. Pour créer un script, vous pouvez utiliser n'importe quel éditeur de texte, mais il est recommandé d'utiliser PowerShell ISE ou Visual Studio Code pour bénéficier de la coloration syntaxique et de l'auto-complétion. Un script peut contenir des cmdlets, des fonctions, des boucles, des conditions, et d'autres structures de contrôle. Voici un exemple simple de script PowerShell qui affiche "Bonjour, monde!" :

Write-Host "Bonjour, monde!"

Pour exécuter un script, vous pouvez utiliser la commande .\nom_du_script.ps1 dans la console PowerShell. Assurez-vous que le script est dans le répertoire courant ou spécifiez le chemin complet.

Politique d'exécution des scripts (Execution Policy)

Pour exécuter un script, vous devez d'abord vous assurer que l'exécution de scripts est autorisée sur votre système. Par défaut, PowerShell bloque l'exécution de scripts pour des raisons de sécurité.

La stratégie d'exécution détermine les conditions dans lesquelles les scripts PowerShell peuvent s'exécuter. Les niveaux de stratégie d'exécution incluent :

Restricted : Aucun script ne peut s'exécuter.
AllSigned : Tous les scripts doivent être signés par un éditeur de confiance.
RemoteSigned : Les scripts téléchargés doivent être signés. Cependant, les scripts locaux non signés peuvent s'exécuter.
Unrestricted : Tous les scripts peuvent s'exécuter.

Vous pouvez vérifier la stratégie d'exécution actuelle avec la commande suivante :

Get-ExecutionPolicy

Pour modifier la stratégie d'exécution, utilisez la commande Set-ExecutionPolicy. Par exemple, pour autoriser l'exécution de scripts téléchargés signés (mais locaux non signés), vous pouvez utiliser :

Set-ExecutionPolicy RemoteSigned

Set-ExecutionPolicy RemoteSigned

Variables

Les variables en PowerShell sont utilisées pour stocker des données temporaires. Elles sont déclarées en utilisant le symbole $ suivi du nom de la variable. Par exemple, pour créer une variable qui stocke un nom, vous pouvez écrire :

$nom = "Eva"

Pour utiliser la valeur d'une variable, vous pouvez simplement taper son nom précédé du symbole $. Par exemple, pour afficher le contenu de la variable $nom, vous pouvez utiliser :

$nom = "Eva"
$message = "Bonjour, $nom!"
Write-Host $message

Les guillemets simples et doubles

Sous PowerShell, les guillements doubles (") et les guillemets simples (') ont des comportements différents. Les guillemets doubles permettent l'interpolation de variables, tandis que les guillemets simples traitent le texte comme une chaîne littérale. Par exemple :

$nom = "Eva"
Write-Host "Bonjour, $nom!"  # Utilise des guillemets doubles
Write-Host 'Bonjour, $nom!'  # Utilise des guillemets simples

Les paramètres

Les scripts PowerShell peuvent également accepter des paramètres, ce qui permet de rendre les scripts plus flexibles et réutilisables. Pour définir des paramètres dans un script, vous pouvez utiliser le bloc param(). Par exemple, pour créer un script qui accepte un nom en paramètre, vous pouvez écrire :

param(
    [string]$nom
)
Write-Host "Bonjour, $nom!"

L'utilisation de [string] avant $nom indique que le paramètre doit être une chaîne de caractères. Vous pouvez également spécifier d'autres types de données, comme [int] pour les entiers ou [bool] pour les valeurs booléennes. Cette annotation aide à valider les entrées et à éviter les erreurs lors de l'exécution du script. Cependant, elle n'est pas obligatoire.

De plus, il est possible de définir des valeurs par défaut pour les paramètres. Par exemple, si vous souhaitez que le script affiche "monde" lorsque aucun nom n'est fourni, vous pouvez modifier le paramètre comme suit :

param(
    [string]$nom = "monde"
)
Write-Host "Bonjour, $nom!"

Ici, la valeur par défaut de $nom est "monde". Si le script est exécuté sans fournir de nom, il affichera "Bonjour, monde!".

Pour exécuter ce script avec un paramètre, vous pouvez utiliser la commande suivante dans la console PowerShell :

.\mon_script.ps1 -nom "Eva"

Il affichera "Bonjour, Eva!". Si vous exécutez le script sans le paramètre -nom, il affichera "Bonjour, monde!" grâce à la valeur par défaut définie.

Substitution de commandes

Une variable peut également stocker le résultat d'une commande. Pour cela, vous pouvez utiliser la syntaxe $(commande). Par exemple, pour stocker la date actuelle dans une variable, vous pouvez écrire :

$dateActuelle = $(Get-Date)
Write-Host "La date actuelle est : $dateActuelle"

Les tableaux

Les tableaux en PowerShell sont utilisés pour stocker plusieurs valeurs dans une seule variable. Vous pouvez créer un tableau en utilisant la syntaxe @(). Par exemple, pour créer un tableau de nombres, vous pouvez écrire :

$tableauNombres = @(1, 2, 3, 4, 5)
Write-Host "Les nombres dans le tableau sont : $tableauNombres"

Pour accéder à un élément spécifique d'un tableau, vous pouvez utiliser l'index de l'élément entre crochets. Par exemple, pour accéder au premier élément du tableau, vous pouvez écrire :

$premierNombre = $tableauNombres[0]
Write-Host "Le premier nombre dans le tableau est : $premierNombre"

Il est également possible de spécifier plusieurs éléments à la fois en utilisant une plage d'indices. Par exemple, pour accéder aux deux premiers éléments du tableau, vous pouvez écrire :

$troisPremiersNombres = $tableauNombres[0..2]
Write-Host "Les trois premiers nombres dans le tableau sont : $troisPremiersNombres"
$troisiemeQuatriemeNombre = $tableauNombres[2,3]
Write-Host "Les troisième et quatrième nombres dans le tableau sont : $troisiemeQuatriemeNombre"
$dernierNombre = $tableauNombres[-1]
Write-Host "Le dernier nombre dans le tableau est : $dernierNombre"

Les index peuvent également être utilisés pour modifier les éléments d'un tableau. Par exemple, pour changer la valeur du deuxième élément du tableau, vous pouvez écrire :

$tableauNombres = @(1, 2, 3, 4, 5)
Write-Host "Les nombres dans le tableau sont : $tableauNombres"
$tableauNombres[1] = 10
Write-Host "Le tableau après modification est : $tableauNombres"

Les tableaux en PowerShell contiennent quelques propriétés et méthodes utiles. Par exemple, vous pouvez utiliser la propriété Count pour obtenir le nombre d'éléments dans un tableau, ou la méthode Add() pour ajouter un élément à la fin du tableau.

$tableauNombres = @(1, 2, 3)
$tableauNombres += 4  # Ajoute le nombre 4 à la fin du tableau
Write-Host "Le tableau contient maintenant : $tableauNombres"
Write-Host "Le nombre d'éléments dans le tableau est : $($tableauNombres.Count)"

Il est également possible de déclarer un tableau sans utiliser la syntaxe @(), en séparant les éléments par des virgules. Par exemple :

$tableauNombres = 1, 2, 3, 4, 5
Write-Host "Les nombres dans le tableau sont : $tableauNombres"

Les chaînes de caractères

Les chaînes de caractères (strings) en PowerShell sont utilisées pour stocker du texte. Comme mentionnée précédemment, elles peuvent être définies en utilisant des guillemets simples (') ou doubles ("). Cependant, il y a des différences importantes entre les deux : les guillemets doubles permettent l'interpolation de variables, tandis que les guillemets simples traitent le texte comme une chaîne littérale.

$chaineSimple = 'Bonjour, $nom!'
$chaineDouble = "Bonjour, $nom!"
Write-Host $chaineSimple
Write-Host $chaineDouble

Ici, le premier Write-Host affichera littéralement , tandis que le second affichera Bonjour, Eva!.

Les chaînes de caractères peuvent également être concaténées en utilisant l'opérateur +. Par exemple :

$chaineConcatenee = $chaineSimple + " " + $chaineDouble
Write-Host $chaineConcatenee

Les chaînes de caractères sont en fait des tableaux de caractères, ce qui signifie que vous pouvez accéder à chaque caractère individuellement en utilisant un index. Par exemple, pour accéder au premier caractère de la chaîne $chaineDouble, vous pouvez écrire :

$premierCaractere = $chaineDouble[0]
Write-Host "Le premier caractère de la chaîne est : $premierCaractere"

Les commentaires

Les commentaires en PowerShell sont utilisés pour ajouter des notes explicatives dans le code. Ils commencent par le symbole # pour les commentaires sur une seule ligne, ou par <# et #> pour les commentaires multi-lignes. Par exemple :

# Ceci est un commentaire sur une seule ligne

<#
Ceci est un commentaire
multi-lignes
#>

Les hashtables (tables de hachage)

Les hashtables en PowerShell sont des collections de paires clé-valeur, similaires aux dictionnaires dans d'autres langages de programmation. Elles sont créées en utilisant la syntaxe @{}. Par exemple, pour créer une hashtable qui stocke des informations sur une personne, vous pouvez écrire :

$personne = @{
    Nom = "Dupont"
    Prénom = "Jean"
    Age = 30
}
Write-Host "Nom : $($personne.Nom), Prénom : $($personne.Prénom), Age : $($personne.Age)"

Pour ajouter une nouvelle paire clé-valeur à une hashtable, vous pouvez utiliser la syntaxe suivante :

$personne["Ville"] = "Montréal"
Write-Host "Ville : $($personne.Ville)"

Les entrées et sorties

Comme vu dans bien des exemples de ce chapitre, pour écrire dans la console, vous pouvez utiliser la cmdlet Write-Host. Par exemple :

Write-Host "Bonjour, monde!"

Pour lire une entrée de l'utilisateur, vous pouvez utiliser la cmdlet Read-Host. Par exemple, pour demander à l'utilisateur son nom et l'afficher ensuite, vous pouvez écrire :

$nom = Read-Host "Entrez votre nom"
Write-Host "Bonjour, $nom!"

Le debogage des scripts sous PowerShell ISE

Puisque Windows PowerShell ISE est un environnement de développement pour PowerShell, il offre des fonctionnalités de débogage, telles que des points d'arrêt, l'exécution pas à pas et l'inspection des variables.

Pour déboguer un script dans PowerShell ISE :

Ouvrez le script dans PowerShell ISE.
Cliquez sur le numéro de ligne à gauche pour ajouter un point d'arrêt.
Exécutez le script en mode débogage en cliquant sur "Déboguer" dans le menu.
Utilisez les commandes de débogage pour examiner l'état du script.