Les structures conditionnelles

Les structures conditionnelles permettent d'exécuter différentes parties de code en fonction de certaines conditions. En PowerShell, les principales structures conditionnelles sont if/elseif/else.

La structure if/elseif/else

La structure if permet d'exécuter un bloc de code si une condition est vraie. Vous pouvez également utiliser elseif pour tester d'autres conditions si la première est fausse, et else pour exécuter un bloc de code si toutes les conditions précédentes sont fausses. Voici la syntaxe de base :

if (condition) {
    # Code à exécuter si la condition est vraie
} elseif (autre_condition) {
    # Code à exécuter si l'autre condition est vraie
} else {
    # Code à exécuter si aucune des conditions précédentes n'est vraie
}

Les opérateurs de comparaison

PowerShell utilise plusieurs opérateurs de comparaison pour évaluer les conditions dans les structures conditionnelles. Voici quelques-uns des opérateurs les plus courants :

  • -eq : égal à
  • -ne : différent de
  • -gt : supérieur à
  • -lt : inférieur à
  • -ge : supérieur ou égal à
  • -le : inférieur ou égal à
  • -like : correspondance avec un motif (utilise des jokers, par exemple * pour plusieurs caractères)
  • -notlike : ne correspond pas à un motif
  • -match : correspondance avec une expression régulière
  • -notmatch : ne correspond pas à une expression régulière
  • is : vérifie si un objet est d'un certain type
  • -isnot : vérifie si un objet n'est pas d'un certain type

Les opérateurs -eq et -ne

L'opérateur -eq est utilisé pour vérifier l'égalité entre deux valeurs. Si les valeurs sont égales, la condition est vraie.

Par exemple, le script suivant vérifie si une variable $age est égale à 18 :

$age = 18
if ($age -eq 18) {
    Write-Host "Vous avez 18 ans."
} else {
    Write-Host "Vous n'avez pas 18 ans."
}

L'opérateur -eq peut être utilisé avec différents types de données, y compris les nombres, les chaînes de caractères et les objets. Pour les chaînes de caractères, la comparaison n'est pas sensible à la casse.

Il existe quelques variantes de l'opérateur -eq pour des comparaisons spécifiques :

  • -ceq : comparaison d'égalité sensible à la casse
  • -ieq : comparaison d'égalité insensible à la casse

À l'inverse de l'opérateur -eq, l'opérateur -ne est utilisé pour vérifier si deux valeurs ne sont pas égales. Si les valeurs sont différentes, la condition est vraie.

Par exemple, le script suivant vérifie si une variable $age n'est pas égale à 18 :

$age = 18
if ($age -ne 18) {
    Write-Host "Vous n'avez pas 18 ans."
} else {
    Write-Host "Vous avez 18 ans."
}

Il existe quelques variantes de l'opérateur -ne pour des comparaisons spécifiques :

  • -cne : comparaison de différence sensible à la casse
  • -ine : comparaison de différence insensible à la casse

Les opérateurs -gt, -lt, -ge et -le

Les opérateurs -gt, -lt, -ge et -le sont utilisés pour comparer des valeurs numériques. Ils permettent de vérifier si une valeur est supérieure, inférieure, supérieure ou égale, ou inférieure ou égale à une autre valeur. Par exemple, le script suivant vérifie si une variable $age est supérieure à 18 :

$age = 20
if ($age -gt 18) {
    Write-Host "Vous êtes majeur."
} else {
    Write-Host "Vous n'êtes pas majeur."
}

Le tableau ci-dessous résume les opérateurs de comparaison numériques :

Opérateur Signification en anglais Signification en français
-gt greater than supérieur à
-lt less than inférieur à
-ge greater than or equal to supérieur ou égal à
-le less than or equal to inférieur ou égal à

Les opérateurs -like et -notlike

Les opérateurs -like et -notlike sont utilisés pour comparer des chaînes de caractères en utilisant des motifs. Ils permettent de vérifier si une chaîne correspond à un motif spécifique, en utilisant des jokers comme * (pour plusieurs caractères) et ? (pour un seul caractère).

Par exemple, le script suivant vérifie si une variable $nom correspond au motif *Smith (c'est-à-dire se termine par "Smith") :

$nom = "John Smith"
if ($nom -like "*Smith") {
    Write-Host "Le nom se termine par 'Smith'."
} else {
    Write-Host "Le nom ne se termine pas par 'Smith'."
}

L'opérateur -notlike fonctionne de manière inverse, vérifiant si une chaîne ne correspond pas à un motif spécifique. Par exemple, le script suivant vérifie si une variable $nom ne correspond pas au motif *Smith :

$nom = "John Doe"
if ($nom -notlike "*Smith") {
    Write-Host "Le nom ne se termine pas par 'Smith'."
} else {
    Write-Host "Le nom se termine par 'Smith'."
}

Le caractère * représente zéro ou plusieurs caractères, tandis que le caractère ? représente un seul caractère. Par exemple, le motif J?n correspondrait à "Jan", "Jen", "Jon", etc, tandis que le motif J*n correspondrait à "John", "Jane", "Jenna", etc.

L'opérateur -is

L'opérateur -is est utilisé pour vérifier si un objet est d'un certain type. Il renvoie vrai si l'objet est du type spécifié, sinon il renvoie faux.

Par exemple, le script suivant vérifie si une variable $nombre est un entier :

$nombre = 42
if ($nombre -is [int]) {
    Write-Host "C'est un entier."
} else {
    Write-Host "Ce n'est pas un entier."
}

L'opérateur -is est particulièrement utile pour vérifier le type d'un objet avant de tenter d'effectuer des opérations spécifiques à ce type. Par exemple, si vous souhaitez effectuer des opérations sur une chaîne de caractères, vous pouvez vérifier si l'objet est une chaîne avant de procéder.

L'exemple suivant montre comment vérifier si une variable est du type System.ServiceProcess.ServiceController avant de faire des opérations spécifiques à ce type :

$service = Get-Service -Name "wuauserv"
if ($service -is [System.ServiceProcess.ServiceController]) {
    Write-Host "C'est un contrôleur de service."
} else {
    Write-Host "Ce n'est pas un contrôleur de service."
}

À l'inverse, l'opérateur -isnot est utilisé pour vérifier si un objet n'est pas d'un certain type. Il renvoie vrai si l'objet n'est pas du type spécifié, sinon il renvoie faux.

Les opérateurs -contains et -in

Les opérateurs -contains et -in sont utilisés pour vérifier si une collection contient un élément spécifique. L'opérateur -contains vérifie si un élément est présent dans une collection, tandis que l'opérateur -in vérifie si un élément est dans une collection. Une collection peut être un tableau, une liste ou tout autre type de collection en PowerShell. Par exemple, le script suivant vérifie si un tableau $nombres contient le nombre 5 :

$nombres = @(1, 2, 3, 4, 5)
if ($nombres -contains 5) {
    Write-Host "Le tableau contient le nombre 5."
} else {
    Write-Host "Le tableau ne contient pas le nombre 5."
}

L'opérateur -in est utilisé pour vérifier si un élément est dans une collection. Il est souvent utilisé dans des structures conditionnelles pour simplifier la syntaxe. Par exemple, le script suivant vérifie si le nombre 5 est dans le tableau $nombres :

if (5 -in $nombres) {
    Write-Host "Le tableau contient le nombre 5."
} else {
    Write-Host "Le tableau ne contient pas le nombre 5."
}

La différence entre -contains et -in est principalement une question de syntaxe. L'opérateur -contains est utilisé pour vérifier si une collection contient un élément, tandis que l'opérateur -in est utilisé pour vérifier si un élément est dans une collection. Les deux opérateurs peuvent être utilisés de manière interchangeable dans de nombreux cas, mais l'utilisation de -in peut rendre le code plus lisible dans certaines situations.

Les opérateurs logiques

Les opérateurs logiques sont utilisés pour combiner plusieurs conditions dans une structure conditionnelle. Les principaux opérateurs logiques en PowerShell sont -and, -or et -not.

L'opérateur -and

L'opérateur -and est utilisé pour combiner deux conditions. La condition combinée est vraie si les deux conditions sont vraies. Par exemple, le script suivant vérifie si une variable $age est supérieure à 18 et si une variable $pays est égale à "Canada" :

if ($age -gt 18 -and $pays -eq "Canada") {
    Write-Host "L'utilisateur est majeur et vit au Canada."
} else {
    Write-Host "L'utilisateur n'est pas majeur ou ne vit pas au Canada."
}

L'opérateur -or

L'opérateur -or est utilisé pour combiner deux conditions. La condition combinée est vraie si l'une des deux conditions est vraie. Par exemple, le script suivant vérifie si une variable $age est inférieure à 18 ou si une variable $pays est égale à "Canada" :

if ($age -lt 18 -or $pays -eq "Canada") {
    Write-Host "L'utilisateur est mineur ou vit au Canada."
} else {
    Write-Host "L'utilisateur est majeur et ne vit pas au Canada."
}

L'opérateur -not

L'opérateur -not est utilisé pour inverser une condition. Il renvoie vrai si la condition est fausse, et faux si la condition est vraie. Par exemple, le script suivant vérifie si une variable $estActif est fausse :

if (-not $estActif) {
    Write-Host "L'utilisateur n'est pas actif."
} else {
    Write-Host "L'utilisateur est actif."
}

Il est également possible de simplement utiliser le symbole ! pour inverser une condition, ce qui est équivalent à -not. Par exemple :

if (!$estActif) {
    Write-Host "L'utilisateur n'est pas actif."
} else {
    Write-Host "L'utilisateur est actif."
}

Respecter les types lors des comparaisons

Il est important de respecter les types de données lors des comparaisons en PowerShell. Sachant que sous PowerShell, tout est un objet, il est important de s'assurer que les types des objets comparés sont compatibles.

Par exemple, si nous voulions comparer le status d'un service, il est important de connaître le type de l'objet avant de faire la comparaison. Voici un exemple où nous vérifions si le service "wuauserv" (Windows Update) est en cours d'exécution :

$service = Get-Service -Name "wuauserv"
if ($service.Status -eq "Running") {
    Write-Host "Le service Windows Update est en cours d'exécution."
} else {
    Write-Host "Le service Windows Update n'est pas en cours d'exécution."
}