Bye Bye Prof

Introdcution à PowerShell

Cours d'Introduction à PowerShell

Table des matières

  1. Introduction
  2. Les notions de base
  3. Rédaction en PowerShell
  4. Les variables
  5. Conditions et boucles
  6. La gestion des E/S
  7. Les fonctions
  8. La gestion des erreurs

Introduction

Introduction à PowerShell

PowerShell est un langage de script et un shell en ligne de commande développé par Microsoft. Il permet d'automatiser des tâches d'administration système et de gérer des configurations sur les systèmes Windows, Linux et macOS.

Le principe de l'automatisation et du scripting

L'automatisation consiste à exécuter des tâches répétitives sans intervention humaine. Le scripting permet de créer des séquences de commandes qui s'exécutent automatiquement.

Avantages de l'automatisation :

Avant PowerShell : MS-DOS, VBScript, WMIC

Avant PowerShell, les administrateurs Windows utilisaient plusieurs outils :

MS-DOS : Interface en ligne de commande limitée avec des commandes simples.

dir
copy fichier.txt D:\backup\

VBScript : Langage de script pour automatiser Windows, syntaxe complexe.

Set objFSO = CreateObject("Scripting.FileSystemObject")
objFSO.CopyFile "C:\fichier.txt", "D:\backup\"

WMIC : Outil en ligne de commande pour accéder aux informations WMI.

wmic process get name,processid

La naissance de PowerShell

PowerShell a été créé par Jeffrey Snover chez Microsoft et publié en 2006. L'objectif était de créer un shell moderne et puissant basé sur le framework .NET.

L'historique des versions de PowerShell

Les bonnes raisons d'apprendre PowerShell

  1. Automatisation complète : Automatiser presque toutes les tâches Windows
  2. Gestion à distance : Administrer des serveurs distants facilement
  3. Intégration .NET : Accès à toute la puissance du framework .NET
  4. Multiplateforme : Fonctionne sur Windows, Linux et macOS
  5. Écosystème riche : Milliers de modules et cmdlets disponibles

Les notions de base

Les notions de base de PowerShell

PowerShell fonctionne avec des objets .NET plutôt qu'avec du texte brut, ce qui le rend beaucoup plus puissant que les shells traditionnels.

L'installation de PowerShell sur Windows

Sur Windows 10/11 : PowerShell 5.1 est préinstallé.

Pour installer PowerShell 7 (version moderne) :

  1. Téléchargez depuis GitHub
  2. Ou utilisez winget :
winget install Microsoft.PowerShell

Voici le liens avec toutes les sources d'installation:

learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-windows

Vérifier la version installée :

$PSVersionTable

Prise en main de la console PowerShell

Pour ouvrir PowerShell :

Exemple de premières commandes :

# Afficher la date actuelle
Get-Date

# Lister les fichiers du répertoire courant (similaire à la commande dir)
Get-ChildItem

# Obtenir des informations sur le système
Get-ComputerInfo

Les cmdlets PowerShell

Les cmdlets (prononcé "command-lets") sont des commandes PowerShell. Elles suivent la convention Verbe-Nom.

Verbes courants :

Exemples :

# Obtenir la liste des processus
Get-Process

# Obtenir les services
Get-Service

# Créer un nouveau dossier
New-Item -Path "C:\Temp\TestDossier" -ItemType Directory

# Arrêter un service (nécessite des droits admin)
Stop-Service -Name "Spooler"

Les paramètres de cmdlets PowerShell

Les paramètres permettent de préciser le comportement d'une cmdlet.

Syntaxe :

Cmdlet-Name -ParameterName Value

Source: https://www.it-connect.fr/chapitres/powershell-les-parametres-de-cmdlets-commandes/

Exemples :

# Obtenir les processus dont le nom commence par "p"
Get-Process -Name p*

# Lister uniquement les fichiers (pas les dossiers)
Get-ChildItem -Path "C:\Windows" -File

# Obtenir les 5 processus utilisant le plus de mémoire
Get-Process | Sort-Object -Property WorkingSet -Descending | Select-Object -First 5

Paramètres communs (Common Parameters) :

# Afficher des informations détaillées
Get-Service -Verbose

# Simuler l'exécution sans l'effectuer
Remove-Item -Path "fichier.txt" -WhatIf

# Demander confirmation
Stop-Process -Name "notepad" -Confirm

Bien utiliser l'aide PowerShell

L'aide PowerShell est essentielle pour apprendre et découvrir les cmdlets.

Commandes d'aide :

# Mettre à jour l'aide (à faire une fois)
Update-Help

# Obtenir l'aide d'une cmdlet
Get-Help Get-Process

# Aide détaillée avec exemples
Get-Help Get-Process -Detailed

# Afficher uniquement les exemples
Get-Help Get-Process -Examples

# Aide complète
Get-Help Get-Process -Full

# Aide en ligne (ouvre le navigateur)
Get-Help Get-Process -Online

Rechercher des cmdlets :

# Chercher toutes les cmdlets contenant "service"
Get-Command *service*

# Chercher toutes les cmdlets avec le verbe "Get"
Get-Command -Verb Get

# Chercher toutes les cmdlets avec le nom "Process"
Get-Command -Noun Process

Analyser un objet avec Get-Member

Get-Member permet de découvrir les propriétés et méthodes d'un objet.

# Analyser un objet Process
Get-Process | Get-Member

# Voir uniquement les propriétés
Get-Process | Get-Member -MemberType Property

# Voir uniquement les méthodes
Get-Process | Get-Member -MemberType Method

Exemple d'utilisation :

# Découvrir qu'un processus a une méthode Kill()
$process = Get-Process -Name "notepad"
$process | Get-Member

# Utiliser la méthode découverte
$process.Kill()

L'utilisation du pipeline avec PowerShell

Le pipeline (|) permet de passer la sortie d'une cmdlet comme entrée d'une autre.

Exemples :

# Obtenir les services arrêtés
Get-Service | Where-Object {$_.Status -eq "Stopped"}

# Obtenir les 10 plus gros fichiers d'un dossier
Get-ChildItem -Path "C:\Windows\System32" -File | 
    Sort-Object -Property Length -Descending | 
    Select-Object -First 10 Name, Length

# Arrêter tous les processus Notepad
Get-Process -Name notepad | Stop-Process

# Compter le nombre de fichiers dans un dossier
Get-ChildItem -Path "C:\Temp" -File | Measure-Object

Les alias de cmdlets PowerShell

Les alias sont des raccourcis pour les cmdlets.

Alias courants :

# ls, dir, gci sont des alias de Get-ChildItem
ls
dir
gci

# cd, chdir sont des alias de Set-Location
cd C:\Windows

# cls, clear sont des alias de Clear-Host
cls

# cat, type, gc sont des alias de Get-Content
cat fichier.txt

Gérer les alias :

Étudier attentivement le alias 

# Lister tous les alias
Get-Alias

# Trouver l'alias d'une cmdlet
Get-Alias -Definition Get-ChildItem

# Créer un alias temporaire
New-Alias -Name list -Value Get-ChildItem

# Supprimer un alias
Remove-Alias -Name list

Les modules PowerShell

Les modules sont des packages contenant des cmdlets, fonctions et ressources.

Commandes de gestion des modules :

# Lister les modules installés
Get-Module -ListAvailable

# Importer un module
Import-Module ActiveDirectory

# Voir les cmdlets d'un module
Get-Command -Module ActiveDirectory

# Installer un module depuis la galerie PowerShell
Install-Module -Name Az

# Mettre à jour un module
Update-Module -Name Az

# Supprimer un module
Uninstall-Module -Name Az

Exemple pratique :

# Installer le module PSReadLine pour améliorer la console
Install-Module -Name PSReadLine -Force

# Vérifier qu'il est installé
Get-Module PSReadLine -ListAvailable

La personnalisation du profil PowerShell

Le profil PowerShell est un script qui s'exécute au démarrage de chaque session.

Localisation du profil :

# Afficher le chemin du profil
$PROFILE

# Vérifier si le profil existe
Test-Path $PROFILE

# Créer le profil s'il n'existe pas
New-Item -Path $PROFILE -ItemType File -Force

# Éditer le profil
notepad $PROFILE

Exemple de personnalisation :

# Contenu du fichier profile.ps1

# Changer la couleur du prompt
function prompt {
    Write-Host "PS " -NoNewline -ForegroundColor Cyan
    Write-Host (Get-Location) -NoNewline -ForegroundColor Yellow
    return "> "
}

# Créer des alias personnalisés
New-Alias -Name np -Value notepad
New-Alias -Name docs -Value "C:\Users\VotreNom\Documents"

# Afficher un message de bienvenue
Write-Host "Bienvenue dans PowerShell!" -ForegroundColor Green

Rédaction en PowerShell

La rédaction de scripts PowerShell

Un script PowerShell est un fichier texte contenant des commandes PowerShell qui s'exécutent séquentiellement.

Les éditeurs de code pour PowerShell

Visual Studio Code (recommandé) :

Ensuite, allez File - Preference - Settings (ou CTRL + , ) et recherchez l'option default afin de vous assurez de mettre l'option Default Language à PowerShell

Ensuite, allez File - Preference - Settings (ou CTRL + , ) et recherchez l'option editor.tab afin de vous assurez de mettre l'option Tab Completion à ON

Finalement, prendre note que vous pouvez en tout moment basculer d'une version de PowerShell à une autre

PowerShell ISE :

Source: https://www.it-connect.fr/chapitres/powershell-differents-editeurs-de-code/

Source: https://www.it-connect.fr/chapitres/powershell-differents-editeurs-de-code/

Autres options :

Les formats de fichiers utilisés par PowerShell

Extensions courantes :

Exemple de création d'un script :

# Créer un nouveau fichier script
New-Item -Path "C:\Scripts\MonScript.ps1" -ItemType File

# Ajouter du contenu
Set-Content -Path "C:\Scripts\MonScript.ps1" -Value "Write-Host 'Bonjour PowerShell!'"

# Exécuter le script
& "C:\Scripts\MonScript.ps1"

# Si vous êtes dans le répertoire
.\MonScript.ps1

La stratégie d'exécution des scripts PowerShell

La stratégie d'exécution est une protection de sécurité qui contrôle l'exécution des scripts.

Niveaux de stratégie :

Gérer la stratégie d'exécution :

# Voir la stratégie actuelle
Get-ExecutionPolicy

# Modifier la stratégie (nécessite des droits admin)
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned

# Modifier temporairement pour la session actuelle
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process

# Exécuter un script en contournant la stratégie
powershell.exe -ExecutionPolicy Bypass -File "MonScript.ps1"

Commenter son code : comment et pourquoi ?

Les commentaires expliquent le code et facilitent la maintenance.

Types de commentaires :

# Commentaire sur une seule ligne

<#
Commentaire
sur plusieurs
lignes
#>

# Bonnes pratiques pour les commentaires
# - Expliquer le "pourquoi", pas le "comment"
# - Commenter les sections complexes
# - Éviter les commentaires évidents

# Exemple : Mauvais commentaire
$date = Get-Date  # Obtenir la date actuelle (évident!)

# Exemple : Bon commentaire
# On utilise la date actuelle pour nommer le fichier de log
$logFile = "log_$(Get-Date -Format 'yyyyMMdd').txt"

<#
.SYNOPSIS
    Ce script sauvegarde les fichiers importants.
.DESCRIPTION
    Copie tous les fichiers .docx du dossier Documents
    vers un dossier de sauvegarde avec horodatage.
.EXAMPLE
    .\Backup-Documents.ps1
#>

Indenter son code : pourquoi et comment ?

L'indentation améliore la lisibilité et la compréhension du code.

Bonnes pratiques :

# Mauvais : code non indenté
if ($true) {
Get-Process
foreach ($item in $items) {
Write-Host $item
}
}

# Bon : code indenté proprement
if ($true) {
    Get-Process
    
    foreach ($item in $items) {
        Write-Host $item
    }
}

# Indentation avec des pipelines
Get-Process |
    Where-Object {$_.CPU -gt 10} |
    Sort-Object -Property CPU -Descending |
    Select-Object -First 5

Utiliser l'autocomplétion

L'autocomplétion accélère la saisie et réduit les erreurs.

Touches utiles :

Exemples :

# Tapez "Get-Proc" puis Tab → Get-Process
# Tapez "Get-Process -" puis Tab → parcourt les paramètres disponibles

# Dans VS Code, tapez "gps" puis Tab → Get-Process (snippet)

Analysez votre code PowerShell avec PSScriptAnalyzer

PSScriptAnalyzer détecte les problèmes de code et les mauvaises pratiques.

Installation et utilisation :

# Installer PSScriptAnalyzer
Install-Module -Name PSScriptAnalyzer -Force

# Analyser un script
Invoke-ScriptAnalyzer -Path "C:\Scripts\MonScript.ps1"

# Analyser avec des règles spécifiques
Invoke-ScriptAnalyzer -Path "MonScript.ps1" -Severity Warning, Error

# Corriger automatiquement certains problèmes
Invoke-ScriptAnalyzer -Path "MonScript.ps1" -Fix

Exemple de problèmes détectés :

# Mauvaise pratique : utilisation d'alias
ls | % {Write-Host $_.Name}

# Bonne pratique : utilisation des noms complets
Get-ChildItem | ForEach-Object {Write-Host $_.Name}

Bonnes pratiques pour les scripts PowerShell

1. Nommer clairement les variables et fonctions

# Mauvais
$x = Get-Date
$a = "C:\Temp"

# Bon
$currentDate = Get-Date
$backupPath = "C:\Temp\Backup"

2. Utiliser les noms complets des cmdlets

# À éviter dans les scripts (OK en console)
gci | % {$_.Name}

# Préféré dans les scripts
Get-ChildItem | ForEach-Object {$_.Name}

3. Gérer les erreurs

# Toujours prévoir la gestion des erreurs
try {
    Get-Content -Path "fichier_inexistant.txt" -ErrorAction Stop
}
catch {
    Write-Warning "Erreur : le fichier n'existe pas."
}

4. Utiliser des paramètres pour rendre le script flexible

param(
    [string]$SourcePath,
    [string]$DestinationPath
)

Copy-Item -Path $SourcePath -Destination $DestinationPath

5. Ajouter de l'aide basée sur les commentaires

<#
.SYNOPSIS
    Copie des fichiers d'un emplacement à un autre.
.PARAMETER SourcePath
    Chemin source des fichiers.
.PARAMETER DestinationPath
    Chemin de destination.
#>

Les variables

Les variables et les opérateurs avec PowerShell

Les variables stockent des données temporaires en mémoire pendant l'exécution d'un script.

À la découverte des variables avec PowerShell

Déclaration et utilisation :

# Créer une variable (le $ est obligatoire)
$nom = "Alice"
$age = 30
$estActif = $true

# Afficher une variable
Write-Host $nom
$age

# Types de données courants
$nombre = 42                          # Int32
$decimal = 3.14                       # Double
$texte = "Bonjour"                    # String
$booleen = $false                     # Boolean
$tableau = @(1, 2, 3, 4, 5)          # Array
$hashtable = @{Nom="Bob"; Age=25}    # Hashtable

# Vérifier le type d'une variable
$nombre.GetType()

# Forcer un type de variable
[int]$nombreEntier = "123"
[string]$texte = 456

Exemples pratiques :

# Stocker le résultat d'une cmdlet
$processes = Get-Process
$services = Get-Service

# Utiliser les variables
$processes | Where-Object {$_.CPU -gt 10}
$services.Count

# Concaténation de chaînes
$prenom = "Jean"
$nom = "Dupont"
$nomComplet = $prenom + " " + $nom
Write-Host "Bonjour $nomComplet"

# Interpolation de chaînes
Write-Host "Il y a $($processes.Count) processus en cours."

Les variables automatiques

PowerShell fournit des variables automatiques avec des informations système.

Variables automatiques courantes :

# Répertoire courant
$PWD

# Répertoire personnel de l'utilisateur
$HOME

# Informations sur PowerShell
$PSVersionTable

# Dernier code de sortie
$LASTEXITCODE

# Variable contenant le dernier objet retourné
$_

# Vrai/Faux
$true
$false

# Valeur nulle
$null

# Chemin du script en cours d'exécution
$PSScriptRoot

# Arguments passés à un script
$args

Exemples d'utilisation :

# Naviguer vers le répertoire personnel
Set-Location $HOME

# Vérifier la version de PowerShell
if ($PSVersionTable.PSVersion.Major -ge 7) {
    Write-Host "Vous utilisez PowerShell 7 ou supérieur"
}

# Utiliser $_ dans un pipeline
1..10 | ForEach-Object { $_ * 2 }

Les variables d'environnement

Les variables d'environnement contiennent des informations sur le système.

Accéder aux variables d'environnement :

# Syntaxe avec $env:
$env:USERNAME
$env:COMPUTERNAME
$env:PATH
$env:TEMP

# Lister toutes les variables d'environnement
Get-ChildItem Env:

# Utilisation pratique
Write-Host "Utilisateur : $env:USERNAME sur $env:COMPUTERNAME"

# Créer/Modifier une variable d'environnement (session)
$env:MA_VARIABLE = "Valeur"

# Créer une variable d'environnement permanente
[System.Environment]::SetEnvironmentVariable("MA_VARIABLE", "Valeur", "User")

Exemples pratiques :

# Construire un chemin vers le dossier temp
$cheminTemp = Join-Path $env:TEMP "MonDossier"
New-Item -Path $cheminTemp -ItemType Directory -Force

# Afficher le profil utilisateur
Write-Host "Profil : $env:USERPROFILE"

La portée des variables

La portée détermine où une variable est accessible.

Niveaux de portée :

Exemples :

# Variable locale (par défaut)
$variableLocale = "Local"

# Variable globale
$global:variableGlobale = "Global"

# Variable de script
$script:variableScript = "Script"

# Variable privée
$private:variablePrivee = "Privée"

# Exemple pratique
function Test-Portee {
    $variableLocale = "Dans la fonction"
    Write-Host $variableLocale           # "Dans la fonction"
    Write-Host $global:variableGlobale   # "Global"
}

Test-Portee
Write-Host $variableLocale               # Valeur d'origine hors fonction

Voici d'autres exemples:

1. Portée Local (par défaut)

function Test-Local {
    $variable = "Je suis locale"
    Write-Host $variable
}

Test-Local  # Affiche : Je suis locale
Write-Host $variable  # N'affiche rien - la variable n'existe pas ici

2. Portée Global

$global:nom = "Alice"

function Afficher-Nom {
    Write-Host $global:nom  # Peut accéder à la variable globale
    $global:nom = "Bob"     # Peut la modifier
}

Write-Host $nom           # Affiche : Alice
Afficher-Nom              # Affiche : Alice
Write-Host $nom           # Affiche : Bob (modifiée par la fonction)

3. Portée Script

# Dans un fichier .ps1
$script:compteur = 0

function Incrementer {
    $script:compteur++
    Write-Host "Compteur: $script:compteur"
}

Incrementer  # Affiche : Compteur: 1
Incrementer  # Affiche : Compteur: 2
Write-Host $compteur  # Affiche : 2

4. Portée Private

function Test-Private {
    $private:secret = "Confidentiel"
    
    function FonctionInterne {
        Write-Host $secret  # ERREUR - ne peut pas accéder
    }
    
    Write-Host $secret  # Fonctionne - même portée
    FonctionInterne
}

Test-Private

5. Exemple pratique combiné

$global:utilisateur = "Système"
$compteur = 0

function Traiter-Donnees {
    $script:total = 100
    $local:temp = 50
    
    Write-Host "Global: $global:utilisateur"
    Write-Host "Local: $temp"
    Write-Host "Externe: $compteur"  # Peut lire la variable parente
}

Traiter-Donnees
Write-Host $temp  # N'affiche rien - variable locale à la fonction

La règle simple : une variable peut lire les portées supérieures, mais pour les modifier il faut utiliser le préfixe explicite ($global:, $script:).

Portée Visibilité Durée de vie Usage typique
Global Partout (Console + Scripts) Tant que la fenêtre est ouverte Préférences utilisateur, profils.
Script Tout le fichier .ps1 Temps d'exécution du script Partager des infos entre fonctions du même script.
Local Bloc actuel ({}) Temps d'exécution du bloc Variables temporaires (boucles, calculs).
Private Bloc actuel UNIQUEMENT Temps d'exécution du bloc Empêcher les sous-fonctions de lire une variable sensible.

Les opérateurs de comparaison

PowerShell utilise des opérateurs spécifiques (différents de C# ou autres langages) :

Opérateurs de base

-eq   # Égal à (equal)
-ne   # Différent de (not equal)
-gt   # Plus grand que (greater than)
-ge   # Plus grand ou égal (greater or equal)
-lt   # Plus petit que (less than)
-le   # Plus petit ou égal (less or equal)

Exemples :

$age = 25

if ($age -eq 25) { Write-Host "Vous avez 25 ans" }
if ($age -ne 30) { Write-Host "Vous n'avez pas 30 ans" }
if ($age -gt 18) { Write-Host "Vous êtes majeur" }
if ($age -le 65) { Write-Host "Pas encore à la retraite" }

Opérateurs de chaînes

-like      # Correspond au motif (avec * et ?)
-notlike   # Ne correspond pas au motif
-match     # Expression régulière
-notmatch  # Pas d'expression régulière

Exemples :

$nom = "Jean-Pierre"

if ($nom -like "Jean*") { Write-Host "Commence par Jean" }
if ($nom -match "^Jean") { Write-Host "Commence par Jean (regex)" }

Sensibilité à la casse

-ceq   # Égal (sensible à la casse)
-ieq   # Égal (insensible à la casse - par défaut)

Opérateurs de comparaison (méli-mélo):

# Égalité
5 -eq 5          # True (equal)
5 -ne 3          # True (not equal)

# Comparaison numérique
10 -gt 5         # True (greater than)
10 -ge 10        # True (greater or equal)
5 -lt 10         # True (less than)
5 -le 5          # True (less or equal)

# Comparaison de chaînes (insensible à la casse par défaut)
"Bonjour" -eq "bonjour"      # True
"Bonjour" -ceq "bonjour"     # False (case-sensitive equal)

# Opérateurs de correspondance
"Bonjour" -like "Bon*"       # True (wildcard)
"Test123" -match "\d+"       # True (regex)

# Contient
$tableau = @(1, 2, 3, 4, 5)
$tableau -contains 3         # True
3 -in $tableau              # True

Exemples pratiques :

# Vérifier si un processus existe
if ((Get-Process -Name "notepad" -ErrorAction SilentlyContinue) -ne $null) {
    Write-Host "Notepad est en cours d'exécution"
}

# Comparer des versions
$version = "7.2.0"
if ($version -ge "7.0.0") {
    Write-Host "Version compatible"
}

# Filtrer avec Where-Object
Get-Service | Where-Object {$_.Status -eq "Running"}

Les opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des calculs mathématiques.

Opérateurs de base :

# Addition
5 + 3           # 8

# Soustraction
10 - 4          # 6

# Multiplication
6 * 7           # 42

# Division
20 / 4          # 5

# Modulo (reste de la division)
10 % 3          # 1

# Opérateurs d'assignation
$x = 10
$x += 5         # $x = 15
$x -= 3         # $x = 12
$x *= 2         # $x = 24
$x /= 4         # $x = 6
$x %= 4         # $x = 2

# Incrément et décrément
$compteur = 0
$compteur++     # 1
$compteur--     # 0

Exemples pratiques :

# Calculer l'espace disque en GB
$bytes = 5368709120
$gigabytes = $bytes / 1GB
Write-Host "$gigabytes GB"

# Calculer un pourcentage
$total = 200
$utilise = 75
$pourcentage = ($utilise / $total) * 100
Write-Host "$pourcentage% utilisé"

# Arrondir un nombre
[Math]::Round(3.14159, 2)    # 3.14
[Math]::Ceiling(3.2)          # 4
[Math]::Floor(3.8)            # 3

Conditions multiples

Opérateur AND (-and)

$age = 25
$permis = $true

# Les DEUX conditions doivent être vraies
if ($age -ge 18 -and $permis -eq $true) {
    Write-Host "Vous pouvez conduire"
}

Opérateur OR (-or)

$jour = "Samedi"

# AU MOINS UNE condition doit être vraie
if ($jour -eq "Samedi" -or $jour -eq "Dimanche") {
    Write-Host "C'est le week-end !"
}

Opérateur NOT (-not ou !)

$connecte = $false

if (-not $connecte) {
    Write-Host "Vous devez vous connecter"
}

# Ou avec !
if (!$connecte) {
    Write-Host "Vous devez vous connecter"
}

Combinaisons complexes

$age = 25
$pays = "France"
$permis = $true

# Utiliser des parenthèses pour grouper
if (($age -ge 18 -and $permis) -or $pays -eq "USA") {
    Write-Host "Conditions remplies"
}

Exemple pratique complet

$note = 75
$presence = 90

if ($note -ge 60 -and $presence -ge 80) {
    Write-Host "Réussite avec bonne présence"
}
elseif ($note -ge 60 -and $presence -lt 80) {
    Write-Host "Réussite mais absences à noter"
}
elseif ($note -lt 60 -and $note -ge 50) {
    Write-Host "Rattrapages possibles"
}
else {
    Write-Host "Échec"
}

Opérateurs de contenance

-contains     # Le tableau contient la valeur
-notcontains  # Le tableau ne contient pas la valeur
-in           # La valeur est dans le tableau
-notin        # La valeur n'est pas dans le tableau

Exemples :

$fruits = @("Pomme", "Banane", "Orange")

if ($fruits -contains "Pomme") {
    Write-Host "Il y a des pommes"
}

if ("Kiwi" -notin $fruits) {
    Write-Host "Pas de kiwi disponible"
}

À retenir

PowerShell utilise des opérateurs avec tirets (-eq, -and) plutôt que des symboles (==, &&), et ils sont insensibles à la casse par défaut !

Conditions et boucles

Les conditions et les boucles avec PowerShell

Les structures de contrôle permettent de prendre des décisions et de répéter des actions.

Les structures conditionnelles : If, Else, ElseIf

La structure If permet d'exécuter du code selon une condition.

Syntaxe de base :

# If simple
$age = 18
if ($age -ge 18) {
    Write-Host "Vous êtes majeur"
}

# If-Else
$temperature = 25
if ($temperature -gt 30) {
    Write-Host "Il fait chaud"
}
else {
    Write-Host "La température est agréable"
}

# If-ElseIf-Else
$note = 15
if ($note -ge 16) {
    Write-Host "Très bien"
}
elseif ($note -ge 14) {
    Write-Host "Bien"
}
elseif ($note -ge 10) {
    Write-Host "Passable"
}
else {
    Write-Host "Insuffisant"
}

Opérateurs logiques :

# ET logique (-and)
$age = 25
$permis = $true
if ($age -ge 18 -and $permis -eq $true) {
    Write-Host "Vous pouvez conduire"
}

# OU logique (-or)
$jour = "Samedi"
if ($jour -eq "Samedi" -or $jour -eq "Dimanche") {
    Write-Host "C'est le week-end!"
}

# NON logique (-not ou !)
$pluie = $false
if (-not $pluie) {
    Write-Host "Beau temps!"
}

Exemples pratiques :

# Vérifier si un fichier existe
$fichier = "C:\Temp\test.txt"
if (Test-Path $fichier) {
    Write-Host "Le fichier existe"
    $contenu = Get-Content $fichier
}
else {
    Write-Host "Le fichier n'existe pas"
    New-Item -Path $fichier -ItemType File
}

# Vérifier un service
$service = Get-Service -Name "Spooler"
if ($service.Status -eq "Running") {
    Write-Host "Le service d'impression fonctionne"
}
else {
    Write-Host "Le service est arrêté"
    # Start-Service -Name "Spooler"
}

Les structures conditionnelles : Switch

Switch permet de tester une variable contre plusieurs valeurs.

Syntaxe de base :

# Switch simple
$jour = "Lundi"
switch ($jour) {
    "Lundi"    { Write-Host "Début de semaine" }
    "Vendredi" { Write-Host "Presque le week-end" }
    "Samedi"   { Write-Host "Week-end!" }
    "Dimanche" { Write-Host "Week-end!" }
    default    { Write-Host "Jour de semaine normal" }
}

# Switch avec plusieurs conditions
$nombre = 5
switch ($nombre) {
    {$_ -lt 0}  { Write-Host "Négatif" }
    {$_ -eq 0}  { Write-Host "Zéro" }
    {$_ -gt 0}  { Write-Host "Positif" }
    {$_ % 2 -eq 0} { Write-Host "Pair" }
    default     { Write-Host "Impair" }
}

# Switch avec correspondance de motif
$extension = ".txt"
switch -Wildcard ($extension) {
    "*.txt"  { Write-Host "Fichier texte" }
    "*.ps1"  { Write-Host "Script PowerShell" }
    "*.doc*" { Write-Host "Document Word" }
    default  { Write-Host "Type de fichier inconnu" }
}

Exemple pratique :

# Menu simple
$choix = Read-Host "Choisissez une option (1-3)"
switch ($choix) {
    "1" {
        Write-Host "Option 1 sélectionnée"
        Get-Process
    }
    "2" {
        Write-Host "Option 2 sélectionnée"
        Get-Service
    }
    "3" {
        Write-Host "Option 3 sélectionnée"
        Get-Date
    }
    default {
        Write-Host "Choix invalide"
    }
}

Les boucles For

La boucle For exécute du code un nombre déterminé de fois.

Syntaxe de base :

# Boucle For classique
for ($i = 0; $i -lt 5; $i++) {
    Write-Host "Itération $i"
}

# Compter de 1 à 10
for ($i = 1; $i -le 10; $i++) {
    Write-Host $i
}

# Compter à rebours
for ($i = 10; $i -ge 0; $i--) {
    Write-Host $i
}

# Pas de 2 en 2
for ($i = 0; $i -le 20; $i += 2) {
    Write-Host "Nombre pair : $i"
}

Exemples pratiques :

# Créer plusieurs dossiers
for ($i = 1; $i -le 5; $i++) {
    $nomDossier = "Dossier_$i"
    New-Item -Path "C:\Temp\$nomDossier" -ItemType Directory -Force
    Write-Host "Créé : $nomDossier"
}

# Table de multiplication
$nombre = 7
for ($i = 1; $i -le 10; $i++) {
    $resultat = $nombre * $i
    Write-Host "$nombre x $i = $resultat"
}

# Parcourir un tableau avec index
$fruits = @("Pomme", "Banane", "Orange", "Fraise")
for ($i = 0; $i -lt $fruits.Count; $i++) {
    Write-Host "Fruit $($i + 1) : $($fruits[$i])"
}

Les boucles ForEach

La boucle ForEach parcourt chaque élément d'une collection.

Syntaxes :

# ForEach-Object (cmdlet)
$nombres = 1..5
$nombres | ForEach-Object {
    Write-Host "Nombre : $_"
}

# foreach (instruction)
$couleurs = @("Rouge", "Vert", "Bleu")
foreach ($couleur in $couleurs) {
    Write-Host "Couleur : $couleur"
}

# Forme courte avec alias
1..10 | % { $_ * 2 }  # % est l'alias de ForEach-Object

Exemples pratiques :

# Traiter tous les fichiers d'un dossier
$fichiers = Get-ChildItem -Path "C:\Temp" -File
foreach ($fichier in $fichiers) {
    Write-Host "Fichier : $($fichier.Name) - Taille : $($fichier.Length) octets"
}

# Arrêter plusieurs processus
$processus = @("notepad", "calc")
foreach ($proc in $processus) {
    Get-Process -Name $proc -ErrorAction SilentlyContinue | Stop-Process
    Write-Host "Processus $proc arrêté"
}

# Créer des utilisateurs (exemple)
$utilisateurs = @(
    @{Nom="Dupont"; Prenom="Jean"},
    @{Nom="Martin"; Prenom="Marie"},
    @{Nom="Bernard"; Prenom="Pierre"}
)

foreach ($user in $utilisateurs) {
    $login = "$($user.Prenom).$($user.Nom)".ToLower()
    Write-Host "Création de l'utilisateur : $login"
}

# Filtrer et traiter
Get-Service | ForEach-Object {
    if ($_.Status -eq "Stopped") {
        Write-Host "$($_.Name) est arrêté" -ForegroundColor Red
    }
}

Les boucles While, Do-While et Do-Until

Ces boucles s'exécutent tant qu'une condition est vraie ou fausse.

While - Vérifie la condition AVANT d'exécuter :

# Boucle While
$compteur = 0
while ($compteur -lt 5) {
    Write-Host "Compteur : $compteur"
    $compteur++
}

# Exemple : attendre qu'un fichier existe
$fichier = "C:\Temp\ready.txt"
while (-not (Test-Path $fichier)) {
    Write-Host "En attente du fichier..."
    Start-Sleep -Seconds 2
}
Write-Host "Fichier trouvé!"

Do-While - Exécute AU MOINS UNE FOIS, puis vérifie :

# Boucle Do-While
$reponse = ""
do {
    $reponse = Read-Host "Voulez-vous continuer? (oui/non)"
} while ($reponse -ne "non")

# Exemple : menu répétitif
do {
    Write-Host "`n=== MENU ==="
    Write-Host "1. Option 1"
    Write-Host "2. Option 2"
    Write-Host "3. Quitter"
    
    $choix = Read-Host "Votre choix"
    
    switch ($choix) {
        "1" { Write-Host "Option 1 exécutée" }
        "2" { Write-Host "Option 2 exécutée" }
        "3" { Write-Host "Au revoir!" }
        default { Write-Host "Choix invalide" }
    }
} while ($choix -ne "3")

Do-Until - Exécute jusqu'à ce que la condition soit VRAIE :

# Boucle Do-Until
$nombre = 0
do {
    $nombre = Get-Random -Minimum 1 -Maximum 10
    Write-Host "Nombre tiré : $nombre"
} until ($nombre -eq 7)
Write-Host "Le nombre 7 a été trouvé!"

# Exemple : attendre qu'un service démarre
$serviceName = "Spooler"
do {
    $service = Get-Service -Name $serviceName
    if ($service.Status -ne "Running") {
        Write-Host "Service pas encore démarré, attente..."
        Start-Sleep -Seconds 1
    }
} until ($service.Status -eq "Running")
Write-Host "Service démarré!"

Contrôle des boucles :

# Break : sortir de la boucle
for ($i = 0; $i -lt 10; $i++) {
    if ($i -eq 5) {
        break  # Sort de la boucle à 5
    }
    Write-Host $i
}

# Continue : passer à l'itération suivante
for ($i = 0; $i -lt 10; $i++) {
    if ($i % 2 -eq 0) {
        continue  # Saute les nombres pairs
    }
    Write-Host $i  # Affiche uniquement les impairs
}

La gestion des E/S

La gestion des entrées et sorties utilisateur

Les entrées/sorties (E/S) permettent d'interagir avec l'utilisateur et d'afficher des informations.

Afficher des informations avec Write-Host et Write-Output

Write-Host - Affichage direct dans la console :

# Affichage simple
Write-Host "Bonjour PowerShell!"

# Avec couleurs
Write-Host "Message d'information" -ForegroundColor Green
Write-Host "Avertissement" -ForegroundColor Yellow
Write-Host "Erreur" -ForegroundColor Red
Write-Host "Titre important" -ForegroundColor Cyan -BackgroundColor DarkBlue

# Sans retour à la ligne
Write-Host "Chargement" -NoNewline
Start-Sleep -Seconds 1
Write-Host "." -NoNewline
Start-Sleep -Seconds 1
Write-Host "." -NoNewline
Start-Sleep -Seconds 1
Write-Host ". Terminé!"

Write-Output - Envoie des objets dans le pipeline :

# Write-Output retourne un objet
$resultat = Write-Output "Ceci est une chaîne"
$resultat  # Affiche : Ceci est une chaîne

# Différence avec Write-Host
function Test-Output {
    Write-Host "Avec Write-Host"     # Affiché, mais non retourné
    Write-Output "Avec Write-Output"  # Retourné par la fonction
}

$valeur = Test-Output
# $valeur contient uniquement "Avec Write-Output"

Autres cmdlets d'écriture :

# Write-Verbose : messages détaillés (nécessite -Verbose)
Write-Verbose "Message de débogage détaillé" -Verbose

# Write-Warning : avertissements
Write-Warning "Ceci est un avertissement"

# Write-Error : erreurs sans arrêter le script
Write-Error "Ceci est une erreur"

# Write-Debug : messages de débogage (nécessite -Debug)
Write-Debug "Point de débogage" -Debug

# Write-Information : informations (PowerShell 5+)
Write-Information "Information importante" -InformationAction Continue

Mettre en forme la sortie dans la console PowerShell

Format-Table - Affichage en tableau :

# Tableau simple
Get-Process | Format-Table Name, CPU, WorkingSet

# Avec sélection de colonnes
Get-Process | Format-Table Name, Id, CPU -AutoSize

# Grouper par propriété
Get-Service | Sort-Object Status | Format-Table -GroupBy Status

Format-List - Affichage en liste :

# Liste complète
Get-Process -Name "powershell" | Format-List *

# Propriétés spécifiques
Get-Process -Name "powershell" | Format-List Name, Id, CPU, WorkingSet

Format-Wide - Affichage en colonnes :

# Noms de fichiers sur plusieurs colonnes
Get-ChildItem | Format-Wide Name -Column 3

Out-GridView - Affichage dans une fenêtre graphique :

# Fenêtre interactive avec filtres
Get-Process | Out-GridView

# Permettre la sélection
$selection = Get-Process | Out-GridView -PassThru
$selection | Stop-Process

Exemples pratiques :

# Créer un rapport formaté
Get-Service |
    Where-Object {$_.Status -eq "Running"} |
    Select-Object Name, DisplayName, Status |
    Format-Table -AutoSize

# Afficher une barre de progression
for ($i = 0; $i -le 100; $i++) {
    Write-Progress -Activity "Traitement en cours" -Status "$i% Complété" -PercentComplete $i
    Start-Sleep -Milliseconds 50
}

Saisie utilisateur interactive avec Read-Host

Read-Host permet de demander des informations à l'utilisateur.

Utilisation de base :

# Saisie simple
$nom = Read-Host "Quel est votre nom?"
Write-Host "Bonjour, $nom!"

# Saisie sécurisée (masque la saisie)
$motDePasse = Read-Host "Mot de passe" -AsSecureString

# Convertir SecureString en texte (pour tests uniquement)
$BSTR = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($motDePasse)
$plainPassword = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($BSTR)

Exemples pratiques :

# Script interactif de copie
$source = Read-Host "Chemin source"
$destination = Read-Host "Chemin destination"

if (Test-Path $source) {
    Copy-Item -Path $source -Destination $destination -Recurse
    Write-Host "Copie terminée!" -ForegroundColor Green
}
else {
    Write-Host "Le chemin source n'existe pas" -ForegroundColor Red
}

# Validation de saisie
do {
    $age = Read-Host "Quel est votre âge?"
    $ageValide = $age -match '^\d+$' -and [int]$age -gt 0
    if (-not $ageValide) {
        Write-Host "Veuillez entrer un nombre valide" -ForegroundColor Yellow
    }
} until ($ageValide)

Write-Host "Vous avez $age ans"

# Menu interactif
Write-Host "`n=== MENU PRINCIPAL ===" -ForegroundColor Cyan
Write-Host "1. Afficher les processus"
Write-Host "2. Afficher les services"
Write-Host "3. Afficher la date"
Write-Host "4. Quitter"

$choix = Read-Host "`nVotre choix (1-4)"

switch ($choix) {
    "1" { Get-Process | Format-Table -AutoSize }
    "2" { Get-Service | Format-Table -AutoSize }
    "3" { Get-Date }
    "4" { Write-Host "Au revoir!" }
    default { Write-Host "Choix invalide" -ForegroundColor Red }
}

Attendre d'appuyer sur « Entrée » dans un script PowerShell

Pause dans le script :

# Méthode 1 : Read-Host
Write-Host "Traitement terminé"
Read-Host "Appuyez sur Entrée pour continuer"

# Méthode 2 : pause (alias de Read-Host)
Write-Host "Première partie terminée"
pause

# Méthode 3 : $host.UI.RawUI.ReadKey
Write-Host "Appuyez sur une touche pour continuer..."
$null = $host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")

# Exemple pratique : script avec étapes
Write-Host "=== Étape 1 : Préparation ===" -ForegroundColor Cyan
# ... code ...
Write-Host "Étape 1 terminée"
Read-Host "Appuyez sur Entrée pour passer à l'étape 2"

Write-Host "`n=== Étape 2 : Traitement ===" -ForegroundColor Cyan
# ... code ...
Write-Host "Étape 2 terminée"
Read-Host "Appuyez sur Entrée pour passer à l'étape 3"

Write-Host "`n=== Étape 3 : Finalisation ===" -ForegroundColor Cyan
# ... code ...
Write-Host "Toutes les étapes sont terminées!" -ForegroundColor Green

Les fonctions

Les fonctions avec PowerShell

Les fonctions permettent de regrouper du code réutilisable et de structurer les scripts.

À quoi sert une fonction ?

Avantages des fonctions :

Créer sa première fonction PowerShell

Syntaxe de base :

function Nom-Fonction {
    # Code à exécuter
}

Exemples simples

1. Fonction basique sans paramètres

function Dire-Bonjour {
    Write-Host "Bonjour tout le monde!"
}

# Appel de la fonction
Dire-Bonjour

2. Fonction avec un paramètre

function Saluer-Personne {
    param(
        [string]$Nom
    )
    Write-Host "Bonjour $Nom, comment vas-tu?"
}

# Appel avec argument
Saluer-Personne -Nom "Marie"

3. Fonction avec plusieurs paramètres

function Calculer-Somme {
    param(
        [int]$Nombre1,
        [int]$Nombre2
    )
    $resultat = $Nombre1 + $Nombre2
    Write-Host "La somme de $Nombre1 et $Nombre2 est : $resultat"
}

Calculer-Somme -Nombre1 5 -Nombre2 10

Qu'arrive-t-il si vous essayez d'afficher la valeur de la variable $resultat tout de suite après avoir appelé la fonction Calculer-Somme

Calculer-Somme -Nombre1 5 -Nombre2 10

Write-Host $resultat

Hint: Voir le chapitre sur la portée de la variable

4. Fonction qui retourne une valeur

function Multiplier {
    param(
        [int]$a,
        [int]$b
    )
    return $a * $b
}

$resultat = Multiplier -a 4 -b 7
Write-Host "Résultat: $resultat"  # Affiche: Résultat: 28

5. Fonction avec paramètre par défaut

function Afficher-Message {
    param(
        [string]$Message = "Message par défaut"
    )
    Write-Host $Message
}

Afficher-Message  # Utilise la valeur par défaut
Afficher-Message -Message "Mon message personnalisé"

Conseils pratiques

Exemples pratiques :

# Fonction de sauvegarde de fichiers
function Backup-Files {
    param(
        $SourcePath,
        $DestinationPath
    )
    
    if (Test-Path $SourcePath) {
        $date = Get-Date -Format "yyyyMMdd_HHmmss"
        $backupPath = Join-Path $DestinationPath "Backup_$date"
        
        Copy-Item -Path $SourcePath -Destination $backupPath -Recurse
        Write-Host "Sauvegarde créée : $backupPath" -ForegroundColor Green
    }
    else {
        Write-Host "Le chemin source n'existe pas" -ForegroundColor Red
    }
}

# Utilisation
Backup-Files -SourcePath "C:\Documents" -DestinationPath "D:\Backups"

# Fonction pour obtenir la taille d'un dossier
function Get-FolderSize {
    param($Path)
    
    $size = (Get-ChildItem -Path $Path -Recurse -File | 
             Measure-Object -Property Length -Sum).Sum
    
    $sizeGB = [Math]::Round($size / 1GB, 2)
    return "$sizeGB GB"
}

$taille = Get-FolderSize -Path "C:\Windows"
Write-Host "Taille du dossier Windows : $taille"

Ajouter des contrôles sur les paramètres de fonction

Validation des paramètres :

# Paramètre obligatoire
function Get-UserInfo {
    param(
        [Parameter(Mandatory=$true)]
        [string]$Username
    )
    Write-Host "Utilisateur : $Username"
}

# Appellera une invite si -Username n'est pas fourni
Get-UserInfo

# Validation du type
function Calculer-Carre {
    param(
        [Parameter(Mandatory=$true)]
        [int]$Nombre
    )
    return $Nombre * $Nombre
}

Calculer-Carre -Nombre 5  # OK
# Calculer-Carre -Nombre "abc"  # Erreur

# Valeur par défaut
function Write-Message {
    param(
        [string]$Message = "Message par défaut"
    )
    Write-Host $Message
}

Write-Message  # Affiche "Message par défaut"
Write-Message -Message "Mon message"

# Validation de plage
function Set-Volume {
    param(
        [ValidateRange(0, 100)]
        [int]$Level
    )
    Write-Host "Volume réglé à $Level%"
}

Set-Volume -Level 50   # OK
# Set-Volume -Level 150  # Erreur

# Validation d'ensemble
function Set-Environment {
    param(
        [ValidateSet("Dev", "Test", "Prod")]
        [string]$Environment
    )
    Write-Host "Environnement : $Environment"
}

Set-Environment -Environment "Prod"  # OK
# Set-Environment -Environment "Local"  # Erreur

# Validation de motif (regex)
function Set-Email {
    param(
        [ValidatePattern("^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$")]
        [string]$Email
    )
    Write-Host "Email : $Email"
}

Set-Email -Email "user@example.com"  # OK
# Set-Email -Email "invalid-email"  # Erreur

Exemple complet avec validations :

function New-User {
    param(
        [Parameter(Mandatory=$true)]
        [ValidateLength(3, 20)]
        [string]$Username,
        
        [Parameter(Mandatory=$true)]
        [ValidatePattern("^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$")]
        [string]$Email,
        
        [ValidateRange(18, 100)]
        [int]$Age = 18,
        
        [ValidateSet("Admin", "User", "Guest")]
        [string]$Role = "User"
    )
    
    Write-Host "=== Nouvel utilisateur ===" -ForegroundColor Cyan
    Write-Host "Nom : $Username"
    Write-Host "Email : $Email"
    Write-Host "Âge : $Age"
    Write-Host "Rôle : $Role"
}

# Utilisation
New-User -Username "JDoe" -Email "jdoe@example.com" -Age 25 -Role "Admin"

Gérer la position des paramètres de fonction

Paramètres positionnels :

# Sans position explicite (ordre de déclaration)
function Copy-File {
    param(
        [string]$Source,
        [string]$Destination
    )
    Copy-Item -Path $Source -Destination $Destination
}

# Appel avec noms de paramètres
Copy-File -Source "file.txt" -Destination "backup.txt"

# Avec position explicite
function Copy-FilePositional {
    param(
        [Parameter(Position=0)]
        [string]$Source,
        
        [Parameter(Position=1)]
        [string]$Destination
    )
    Copy-Item -Path $Source -Destination $Destination
}

# Appel sans noms de paramètres (utilise la position)
Copy-FilePositional "file.txt" "backup.txt"

# Mélange de positionnel et nommé
function New-Greeting {
    param(
        [Parameter(Position=0)]
        [string]$Name,
        
        [Parameter(Position=1)]
        [string]$Greeting = "Bonjour",
        
        [switch]$Enthusiastic
    )
    
    $message = "$Greeting, $Name"
    if ($Enthusiastic) {
        $message += "!"
    }
    Write-Host $message
}

New-Greeting "Alice"                           # "Bonjour, Alice"
New-Greeting "Bob" "Salut"                     # "Salut, Bob"
New-Greeting "Charlie" -Enthusiastic           # "Bonjour, Charlie!"
New-Greeting "David" "Hey" -Enthusiastic       # "Hey, David!"

La gestion des erreurs

La gestion des erreurs

La gestion des erreurs permet de contrôler le comportement du script en cas de problème.

Le fonctionnement des erreurs avec PowerShell

Types d'erreurs :

Erreurs terminales (Terminating) : Arrêtent l'exécution du script
Erreurs non-terminales (Non-Terminating) : Affichent une erreur mais continuent

Variables d'erreur :

# $Error : tableau contenant toutes les erreurs
$Error[0]  # Dernière erreur
$Error.Count  # Nombre d'erreurs

# Effacer les erreurs
$Error.Clear()

# ErrorActionPreference : comportement par défaut
$ErrorActionPreference  # Valeur par défaut : "Continue"

Actions d'erreur (ErrorAction) :

# Exemples d'ErrorAction
Get-Process -Name "InexistantProcess" -ErrorAction SilentlyContinue
Get-Content "FichierInexistant.txt" -ErrorAction Stop
Get-Item "C:\Inexistant" -ErrorAction Inquire

Gérer les erreurs avec Try-Catch-Finally

Voici des exemples simples et progressifs pour comprendre la structure Try, Catch, Finally en PowerShell.

Le principe est de gérer les erreurs proprement au lieu de laisser le script planter ou afficher du texte rouge effrayant à l'utilisateur.

1. L'exemple le plus simple (Division par zéro)

C'est la structure de base : on "essaie" une action risquée, et si elle échoue, on "attrape" l'erreur.

try {
    # On tente une action impossible
    $resultat = 10 / 0
}
catch {
    # Ce bloc s'exécute UNIQUEMENT s'il y a une erreur
    Write-Warning "Attention : Impossible de diviser par zéro !"
}

2. Récupérer le message d'erreur réel

Souvent, vous voulez savoir pourquoi ça a planté. L'erreur est stockée automatiquement dans la variable $_ à l'intérieur du bloc catch.

try {
    # On essaie d'ouvrir un fichier qui n'existe pas
    Get-Item "C:\Fichier_Fantome.txt" -ErrorAction Stop
}
catch {
    Write-Host "Une erreur est survenue :" -ForegroundColor Red
    # Affiche le message système de l'erreur
    Write-Host $_.Exception.Message -ForegroundColor Yellow
}

Note importante (-ErrorAction Stop) :

En PowerShell, beaucoup d'erreurs (comme un fichier non trouvé) ne stoppent pas le script par défaut (ce sont des erreurs "non-terminating"). Pour que le try/catch fonctionne sur des commandes cmdlets, il faut souvent ajouter -ErrorAction Stop à la fin de la commande.


3. L'exemple complet avec "Finally"

Le bloc finally est optionnel, mais très utile. Il s'exécute quoi qu'il arrive (succès ou erreur). On l'utilise souvent pour du "nettoyage" (fermer une connexion, libérer un fichier, etc.).

try {
    Write-Host "1. Début du traitement..."
    
    # Simuler une erreur fatale
    Throw "Oups, une erreur grave !"
    
    Write-Host "Ce texte ne s'affichera jamais car l'erreur est avant."
}
catch {
    Write-Host "2. Erreur attrapée : $_" -ForegroundColor Red
}
finally {
    # Ce code tourne TOUJOURS, même après l'erreur
    Write-Host "3. Nettoyage de fin de script (Finally)." -ForegroundColor Green
}

Résultat de ce script :

Début du traitement...

Erreur attrapée : Oups, une erreur grave !

Nettoyage de fin de script (Finally).


Résumé rapide

Bloc Rôle
try { ... } Contient le code risqué qui pourrait échouer.
catch { ... } Ne s'exécute que si une erreur survient dans le try.
finally { ... } S'exécute toujours à la toute fin (optionnel).

Un autre exemple de la structure Try-Catch-Finally :

# Syntaxe de base
try {
    # Code qui peut générer une erreur
    Get-Content "FichierInexistant.txt" -ErrorAction Stop
}
catch {
    # Code exécuté en cas d'erreur
    Write-Host "Une erreur s'est produite : $_" -ForegroundColor Red
}

# Avec Finally
try {
    $file = Get-Content "C:\Temp\data.txt" -ErrorAction Stop
    Write-Host "Fichier lu avec succès"
}
catch {
    Write-Host "Erreur de lecture : $($_.Exception.Message)" -ForegroundColor Red
}
finally {
    # Code toujours exécuté (erreur ou non)
    Write-Host "Opération terminée"
}

Captures d'erreurs spécifiques :

try {
    # Code à risque
    $result = 10 / 0
}
catch [System.DivideByZeroException] {
    Write-Host "Division par zéro détectée!" -ForegroundColor Red
}
catch [System.IO.FileNotFoundException] {
    Write-Host "Fichier non trouvé!" -ForegroundColor Red
}
catch {
    # Capture toutes les autres erreurs
    Write-Host "Erreur inattendue : $($_.Exception.Message)" -ForegroundColor Red
}

Exemples pratiques

# Exemple 1 : Lecture de fichier sécurisée

function Read-ConfigFile {
    param([string]$Path)
    
    try {
        if (-not (Test-Path $Path)) {
            throw "Le fichier de configuration n'existe pas : $Path"
        }
        
        $config = Get-Content $Path -ErrorAction Stop | ConvertFrom-Json
        Write-Host "Configuration chargée avec succès" -ForegroundColor Green
        return $config
    }
    catch [System.IO.FileNotFoundException] {
        Write-Error "Fichier non trouvé : $Path"
        return $null
    }
    catch {
        Write-Error "Erreur lors de la lecture : $($_.Exception.Message)"
        return $null
    }
}

# Exemple 2 : Connexion avec gestion d'erreur

function Connect-ToServer {
    param(
        [string]$ServerName,
        [int]$MaxRetries = 3
    )
    
    $retry = 0
    $connected = $false
    
    while (-not $connected -and $retry -lt $MaxRetries) {
        try {
            Write-Host "Tentative de connexion $($retry + 1)/$MaxRetries..."
            # Test-Connection -ComputerName $ServerName -Count 1 -ErrorAction Stop
            # ... code de connexion ...
            $connected = $true
            Write-Host "Connecté à $ServerName" -ForegroundColor Green
        }
        catch {
            $retry++
            if ($retry -lt $MaxRetries) {
                Write-Warning "Échec de connexion. Nouvelle tentative dans 5 secondes..."
                Start-Sleep -Seconds 5
            }
            else {
                Write-Error "Impossible de se connecter après $MaxRetries tentatives"
                throw
            }
        }
    }
}

# Exemple 3 : Traitement de fichiers avec nettoyage

function Process-DataFile {
    param([string]$FilePath)
    
    $tempFile = $null
    
    try {
        # Créer un fichier temporaire
        $tempFile = New-TemporaryFile
        Write-Verbose "Fichier temporaire créé : $($tempFile.FullName)"
        
        # Traiter les données
        $data = Get-Content $FilePath -ErrorAction Stop
        $processed = $data | ForEach-Object { $_.ToUpper() }
        
        # Sauvegarder dans le fichier temp
        $processed | Set-Content $tempFile.FullName
        
        Write-Host "Traitement réussi" -ForegroundColor Green
        return $tempFile.FullName
    }
    catch {
        Write-Error "Erreur pendant le traitement : $($_.Exception.Message)"
        return $null
    }
    finally {
        # Nettoyage (toujours exécuté)
        if ($tempFile -and (Test-Path $tempFile.FullName)) {
            # Remove-Item $tempFile.FullName -Force
            Write-Verbose "Fichier temporaire nettoyé"
        }
    }
}

# Exemple 4 : Script complet avec gestion d'erreurs

# Exemple 4 : Script complet avec gestion d'erreurs
function Backup-ImportantFiles {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$SourcePath,
        
        [Parameter(Mandatory=$true)]
        [string]$BackupPath
    )
    
    $ErrorActionPreference = "Stop"
    
    try {
        # Vérifier que la source existe
        if (-not (Test-Path $SourcePath)) {
            throw "Le chemin source n'existe pas : $SourcePath"
        }
        
        # Créer le dossier de backup s'il n'existe pas
        if (-not (Test-Path $BackupPath)) {
            New-Item -Path $BackupPath -ItemType Directory -Force | Out-Null
            Write-Verbose "Dossier de backup créé : $BackupPath"
        }
        
        # Générer le nom du backup
        $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
        $backupFolder = Join-Path $BackupPath "Backup_$timestamp"
        
        # Effectuer la copie
        Write-Host "Début de la sauvegarde..." -ForegroundColor Cyan
        Copy-Item -Path $SourcePath -Destination $backupFolder -Recurse -Force
        
        # Vérifier que la copie a réussi
        if (Test-Path $backupFolder) {
            $itemCount = (Get-ChildItem $backupFolder -Recurse).Count
            Write-Host "Sauvegarde terminée : $itemCount éléments copiés" -ForegroundColor Green
            Write-Host "Emplacement : $backupFolder" -ForegroundColor Green
            return $backupFolder
        }
        else {
            throw "La sauvegarde a échoué : le dossier de destination n'a pas été créé"
        }
    }
    catch [System.UnauthorizedAccessException] {
        Write-Error "Accès refusé. Vérifiez vos permissions."
        return $null
    }
    catch [System.IO.IOException] {
        Write-Error "Erreur d'entrée/sortie : $($_.Exception.Message)"
        return $null
    }
    catch {
        Write-Error "Erreur inattendue : $($_.Exception.Message)"
        Write-Verbose $_.ScriptStackTrace
        return $null
    }
    finally {
        Write-Host "Opération de sauvegarde terminée" -ForegroundColor Cyan
    }
}

# Utilisation
Backup-ImportantFiles -SourcePath "C:\Documents" -BackupPath "D:\Backups" -Verbose

Bonnes pratiques de gestion d'erreurs

# 1. Toujours utiliser -ErrorAction Stop dans try/catch

try {
    Get-Content "fichier.txt" -ErrorAction Stop
}
catch {
    Write-Error "Erreur : $($_.Exception.Message)"
}

# 2. Fournir des messages d'erreur clairs

catch {
    Write-Error "Impossible de lire le fichier de configuration. Vérifiez que le fichier existe et que vous avez les permissions nécessaires."
}

# 3. Logger les erreurs pour le débogage

catch {
    $errorDetails = @{
        Time = Get-Date
        Error = $_.Exception.Message
        Script = $_.InvocationInfo.ScriptName
        Line = $_.InvocationInfo.ScriptLineNumber
    }
    $errorDetails | ConvertTo-Json | Out-File "C:\Logs\errors.log" -Append
}

# 4. Utiliser Finally pour le nettoyage

try {
    $stream = [System.IO.File]::Open("file.txt", "Open")
    # Traitement...
}
finally {
    if ($stream) {
        $stream.Close()
        $stream.Dispose()
    }
}

Conclusion

Ce cours vous a présenté les fondamentaux de PowerShell :

  1. Introduction : Comprendre l'origine et l'intérêt de PowerShell
  2. Notions de base : Cmdlets, pipeline, modules et personnalisation
  3. Rédaction : Bonnes pratiques pour écrire des scripts maintenables
  4. Variables : Stockage et manipulation de données
  5. Conditions et boucles : Contrôle du flux d'exécution
  6. Entrées/Sorties : Interaction avec l'utilisateur
  7. Fonctions : Création de code réutilisable et structuré
  8. Gestion d'erreurs : Robustesse et fiabilité des scripts

Pour aller plus loin :

Ressources utiles :