¶ Cours d'Introduction à PowerShell
¶ Table des matières
- Introduction
- Les notions de base
- Rédaction en PowerShell
- Les variables
- Conditions et boucles
- La gestion des E/S
- Les fonctions
- 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 :
- Gain de temps sur les tâches répétitives
- Réduction des erreurs humaines
- Standardisation des processus
- Possibilité d'exécuter des tâches complexes
¶ 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
- PowerShell 1.0 (2006) : Première version pour Windows XP/Server 2003
- PowerShell 2.0 (2009) : Ajout de remoting et modules
- PowerShell 3.0 (2012) : Workflow et sessions améliorées
- PowerShell 4.0 (2013) : Desired State Configuration (DSC)
- PowerShell 5.0/5.1 (2016) : Classes PowerShell, PackageManagement
- PowerShell Core 6.x (2018) : Version open-source et multiplateforme
- PowerShell 7.x (2020-présent) : Unification et compatibilité améliorée
¶ Les bonnes raisons d'apprendre PowerShell
- Automatisation complète : Automatiser presque toutes les tâches Windows
- Gestion à distance : Administrer des serveurs distants facilement
- Intégration .NET : Accès à toute la puissance du framework .NET
- Multiplateforme : Fonctionne sur Windows, Linux et macOS
- É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) :
- Téléchargez depuis GitHub
- 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 :
- Recherchez "PowerShell" dans le menu Démarrer
- Ou appuyez sur Win+X et sélectionnez "Windows 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 :
- Get : Obtenir des informations
- Set : Modifier des paramètres
- New : Créer quelque chose
- Remove : Supprimer quelque chose
- Start/Stop : Démarrer/Arrêter un processus/service
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
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é) :
- Lien: Téléchargement
- Gratuit et multiplateforme
- Extension PowerShell officielle
- IntelliSense et débogage intégrés
- Ne pas oublier de rajouter l'extension PowerShell à Visual Stuido Code
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 :
- Inclus avec Windows
- Interface simple pour débuter
- Limité à Windows PowerShell 5.1
Autres options :
- Notepad++
- Sublime Text
- Visual Studio
¶ Les formats de fichiers utilisés par PowerShell
Extensions courantes :
.ps1: Script PowerShell.psm1: Module PowerShell.psd1: Manifeste de module.ps1xml: Fichier de configuration XML
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 :
- Restricted : Aucun script ne peut s'exécuter (par défaut)
- AllSigned : Seuls les scripts signés peuvent s'exécuter
- RemoteSigned : Scripts locaux OK, scripts distants doivent être signés
- Unrestricted : Tous les scripts peuvent s'exécuter (avec avertissement)
- Bypass : Aucune restriction
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 :
- Tab : Compléter une commande ou un paramètre
- Ctrl+Space : Afficher les suggestions (dans VS Code)
- F8 : Exécuter la ligne ou la sélection (dans ISE)
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 :
- Global : Accessible partout
- Script : Accessible uniquement dans le script
- Local : Accessible uniquement dans le bloc courant (par défaut)
- Private : Accessible uniquement dans la portée actuelle
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 fonctionVoici 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 fonctionLa 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èreExemples :
$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 tableauExemples :
$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 StatusFormat-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 3Out-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-ProcessExemples 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 :
- Réutilisabilité du code
- Facilite la maintenance
- Améliore la lisibilité
- Permet la modularité
- Évite la duplication de code
¶ 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 10Qu'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
- Utilisez des noms descriptifs avec le format
Verbe-Nom(convention PowerShell) - Déclarez toujours vos paramètres avec
param() - Utilisez
returnpour renvoyer des valeurs - Ajoutez des types aux paramètres pour valider les entrées (
[int],[string], etc.)
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 "[email protected]" # OK
# Set-Email -Email "invalid-email" # ErreurExemple 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 "[email protected]" -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) :
- Continue : Affiche l'erreur et continue (par défaut)
- SilentlyContinue : Continue sans afficher l'erreur
- Stop : Transforme l'erreur en erreur terminale
- Inquire : Demande à l'utilisateur quoi faire
- Ignore : Ignore complètement l'erreur
# 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/catchfonctionne 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 :
- Introduction : Comprendre l'origine et l'intérêt de PowerShell
- Notions de base : Cmdlets, pipeline, modules et personnalisation
- Rédaction : Bonnes pratiques pour écrire des scripts maintenables
- Variables : Stockage et manipulation de données
- Conditions et boucles : Contrôle du flux d'exécution
- Entrées/Sorties : Interaction avec l'utilisateur
- Fonctions : Création de code réutilisable et structuré
- Gestion d'erreurs : Robustesse et fiabilité des scripts
Pour aller plus loin :
- Pratiquez régulièrement avec des scripts réels
- Explorez les modules PowerShell pour Active Directory, Azure, etc.
- Consultez la documentation officielle Microsoft
- Participez à la communauté PowerShell
Ressources utiles :
- Documentation officielle : https://docs.microsoft.com/powershell
- PowerShell Gallery : https://www.powershellgallery.com
- Forums et communautés PowerShell