Tout ce que vous vouliez savoir sur l’instruction `if`

Comme de nombreux autres langages, PowerShell contient des instructions pour l’exécution conditionnelle du code dans vos scripts. L’une de ces instructions est l’instruction If . Aujourd’hui, nous allons approfondir l’une des commandes les plus fondamentales dans PowerShell.

Note

La version originale de cet article est apparue sur le blog écrit par @KevinMarquette. L’équipe PowerShell remercie Kevin de partager ce contenu avec nous. Veuillez consulter son blog à PowerShellExplained.com.

Exécution conditionnelle

Vos scripts doivent souvent prendre des décisions et effectuer une logique différente en fonction de ces décisions. C’est ce que je veux dire par l’exécution conditionnelle. Vous avez une instruction ou une valeur à évaluer, puis exécutez une section de code différente en fonction de cette évaluation. C’est exactement ce que fait l’instruction if .

L’instruction `if`.

Voici un exemple de base de l’instruction if :

$condition = $true
if ( $condition )
{
    Write-Output "The condition was true"
}

La première chose que l’instruction if fait est d’évaluer l’expression entre parenthèses. S'il évalue à $true, il exécute les instructions entre les accolades. Si la valeur était $false, elle ignorerait ce bloc d’instructions.

Dans l’exemple précédent, l’instruction if n’évalue que la $condition variable. C'était $true et aurait exécuté la commande Write-Output à l’intérieur du bloc d’instructions.

Dans certains langages, vous pouvez placer une seule ligne de code après l’instruction if et elle est exécutée. Ce n’est pas le cas dans PowerShell. Vous devez fournir un ensemble d'accolades statement block pour que cela fonctionne correctement.

Opérateurs de comparaison

L’utilisation la plus courante de l’instruction if consiste à comparer deux éléments entre eux. PowerShell a des opérateurs spéciaux pour différents scénarios de comparaison. Lorsque vous utilisez un opérateur de comparaison, la valeur du côté gauche est comparée à la valeur du côté droit.

-eq pour l’égalité

La -eq vérification de l’égalité entre deux valeurs permet de s’assurer qu’elles sont égales les unes aux autres.

$value = Get-MysteryValue
if ( 5 -eq $value )
{
    # do something
}

Dans cet exemple, je prends une valeur connue de 5 et je la compare à mon $value pour voir s'ils correspondent.

L’un des cas d’usage possibles consiste à vérifier l’état d’une valeur avant de prendre une action dessus. Vous pourriez obtenir un service et vérifier que l’état était en train de fonctionner avant que vous ne l'appeliez Restart-Service.

Il est courant dans d’autres langages comme C# d’utiliser == pour l’égalité (ex : 5 == $value) mais cela ne fonctionne pas avec PowerShell. Une autre erreur courante que les gens font est d’utiliser le signe égal (ex : 5 = $value) réservé à l’attribution de valeurs à des variables. En plaçant votre valeur connue à gauche, cela rend cette erreur plus maladroite à faire.

Cet opérateur (et d’autres) a quelques variantes.

-eq Égalité non sensible à la casse
-ieq Égalité non sensible à la casse
-ceq Égalité sensible à la casse

-ne pas égal

De nombreux opérateurs ont un opérateur associé qui vérifie le résultat opposé. -ne vérifie que les valeurs ne sont pas égales les unes des autres.

if ( 5 -ne $value )
{
    # do something
}

Utilisez cette option pour vous assurer que l’action s’exécute uniquement si la valeur n’est pas 5. Un bon cas d'utilisation serait de vérifier si un service est en cours d'exécution avant d'essayer de le démarrer.

Variations:

-ne ne respectant pas la casse non égale
-ine ne respectant pas la casse non égale
-cne respectant la casse non égale

Il s’agit de variantes inverses de -eq. Je regrouperai ces types lorsque je répertorie les variantes pour d’autres opérateurs.

-gt pour supérieur à, -ge pour supérieur ou égal à, -lt pour inférieur à, -le pour inférieur ou égal à

Ces opérateurs sont utilisés lors de la vérification pour voir si une valeur est supérieure ou inférieure à une autre valeur. Le -gt -ge -lt -le stand pour GreaterThan, GreaterThanOrEqual, LessThan et LessThanOrEqual.

if ( $value -gt 5 )
{
    # do something
}

Variations:

-gt supérieur à
-igt supérieur à, insensible à la casse
-cgt supérieur à, casse sensible
-ge supérieur ou égal à
-ige supérieur ou égal, insensible à la casse
-cge supérieur ou égal, sensible à la casse
-lt inférieur à
-ilt inférieur à, insensible à la casse
-clt inférieur à, sensible à la casse
-le inférieur ou égal à
-ile inférieur ou égal, non sensible à la casse
-cle inférieur ou égal, sensible à la casse

Je ne sais pas pourquoi vous utiliseriez des options sensibles à la casse et insensibles pour ces opérateurs.

correspondances similaires à des caractères génériques

PowerShell a sa propre syntaxe de correspondance de modèle basé sur des jokers et vous pouvez l’utiliser avec l’opérateur -like. Ces modèles génériques sont assez simples.

? correspond à n’importe quel caractère unique
* correspond à n’importe quel nombre de caractères

$value = 'S-ATX-SQL01'
if ( $value -like 'S-*-SQL??')
{
    # do something
}

Il est important de souligner que le modèle correspond à la chaîne entière. Si vous devez faire correspondre quelque chose au milieu de la chaîne, vous devez placer les * aux deux extrémités de la chaîne.

$value = 'S-ATX-SQL02'
if ( $value -like '*SQL*')
{
    # do something
}

Variations:

-like caractère générique insensible à la casse
-ilike caractère générique ne respectant pas la casse
-clike Caractère générique sensible à la casse
-notlike caractères génériques non respectant la casse non mis en correspondance
-inotlike caractères génériques non respectant la casse non mis en correspondance
-cnotlike Caractère générique sensible à la casse non mis en correspondance

-correspond à l’expression régulière

L’opérateur -match vous permet de vérifier une chaîne pour une correspondance basée sur des expressions régulières. Utilisez cette option lorsque les modèles génériques ne sont pas suffisamment flexibles pour vous.

$value = 'S-ATX-SQL01'
if ( $value -match 'S-\w\w\w-SQL\d\d')
{
    # do something
}

Un modèle regex correspond n’importe où dans la chaîne par défaut. Vous pouvez donc spécifier une sous-chaîne que vous souhaitez mettre en correspondance comme suit :

$value = 'S-ATX-SQL01'
if ( $value -match 'SQL')
{
    # do something
}

Regex est un langage complexe à part entière qui mérite qu'on s'y intéresse. J’en parle plus et -matchles nombreuses façons d’utiliser regex dans un autre article.

Variations:

-match regex ne respectant pas la casse
-imatch regex ne respectant pas la casse
-cmatch regex respectant la casse
-notmatch regex ne respectant pas la casse et non mis en correspondance
-inotmatch regex ne respectant pas la casse et non mis en correspondance
-cnotmatch regex sensible à la casse non correspondante

-est de type

Vous pouvez vérifier le type d’une valeur avec l’opérateur -is .

if ( $value -is [string] )
{
    # do something
}

Vous pouvez l’utiliser si vous travaillez avec des classes ou acceptez différents objets sur le pipeline. Vous pouvez avoir un service ou un nom de service comme entrée. Vérifiez ensuite si vous avez un service et récupérez le service si vous n’avez que le nom.

if ( $Service -isnot [System.ServiceProcess.ServiceController] )
{
    $Service = Get-Service -Name $Service
}

Variations:

-is de type
-isnot non de type

Opérateurs de collection

Lorsque vous utilisez les opérateurs précédents avec une valeur unique, le résultat est $true ou $false. Cela est géré légèrement différemment lors de l’utilisation d’une collection. Chaque élément de la collection est évalué et l’opérateur retourne chaque valeur évaluée à $true.

PS> 1,2,3,4 -eq 3
3

Cela fonctionne toujours correctement dans une if instruction. Par conséquent, une valeur est retournée par votre opérateur, puis l’instruction entière est $true.

$array = 1..6
if ( $array -gt 3 )
{
    # do something
}

Il y a un petit piège caché dans les détails ici que j’ai besoin de souligner. Lors de l’utilisation de l’opérateur -ne de cette façon, il est facile de regarder à tort la logique vers l’arrière. L’utilisation -ne avec une collection retourne $true si un élément de la collection ne correspond pas à votre valeur.

PS> 1,2,3 -ne 4
1
2
3

Cela peut ressembler à une astuce intelligente, mais nous avons des opérateurs -contains et -in qui gèrent cela plus efficacement. Et -notcontains fait ce que vous attendez.

-Contient

L’opérateur -contains vérifie la collection pour votre valeur. Dès qu’il trouve une correspondance, il retourne $true.

$array = 1..6
if ( $array -contains 3 )
{
    # do something
}

Il s’agit de la meilleure façon de voir si une collection contient votre valeur. L'utilisation de Where-Object (ou -eq) parcourt l'ensemble de la liste à chaque fois et est beaucoup plus lente.

Variations:

-contains Correspondance insensible à la casse
-icontains Correspondance insensible à la casse
-ccontains Correspondance sensible à la casse
-notcontains insensible à la casse et pas correspondante
-inotcontains insensible à la casse et non correspondante
-cnotcontains Sensible à la casse non correspondante

-in

L’opérateur -in est tout comme l’opérateur -contains , sauf que la collection se trouve sur le côté droit.

$array = 1..6
if ( 3 -in $array )
{
    # do something
}

Variations:

-in Correspondance insensible à la casse
-iin Correspondance insensible à la casse
-cin Correspondance sensible à la casse
-notin ne respectant pas la casse et non mis en correspondance
-inotin insensible à la casse et non correspondant
-cnotin Sensibilité à la casse non correspondante

Opérateurs logiques

Les opérateurs logiques sont utilisés pour inverser ou combiner d’autres expressions.

-Pas

L’opérateur -not retourne une expression de $false vers $true ou de $true vers $false. Voici un exemple où nous voulons effectuer une action quand Test-Path c’est $false.

if ( -not ( Test-Path -Path $path ) )

La plupart des opérateurs dont nous avons parlé ont une variante où vous n’avez pas besoin d’utiliser l’opérateur -not . Mais il y a encore des moments qu’il est utile.

! opérateur

Vous pouvez utiliser ! comme alias pour -not.

if ( -not $value ){}
if ( !$value ){}

Vous pouvez voir ! utilisé plus souvent par des personnes provenant d'autres langages comme C#. Je préfère le rédiger parce que je trouve qu'il est difficile de voir rapidement lorsque je consulte mes scripts.

-et

Vous pouvez combiner des expressions avec l’opérateur -and . Lorsque vous faites cela, les deux côtés doivent être $true pour que l’expression entière soit $true.

if ( ($age -gt 13) -and ($age -lt 55) )

Dans cet exemple, $age doit être de 13 ou plus pour le côté gauche et inférieur à 55 pour le côté droit. J’ai ajouté des parenthèses supplémentaires pour le rendre plus clair dans cet exemple, mais ils sont facultatifs tant que l’expression est simple. Voici le même exemple sans eux.

if ( $age -gt 13 -and $age -lt 55 )

L’évaluation se produit de gauche à droite. Si le premier élément est évalué à $false, il sort prématurément et ne réalise pas la comparaison de droite. Cela est pratique lorsque vous devez vous assurer qu’une valeur existe avant de l’utiliser. Par exemple, Test-Path lève une erreur si vous lui donnez un $null chemin d’accès.

if ( $null -ne $path -and (Test-Path -Path $path) )

-Ou

Vous pouvez spécifier deux expressions et retourner $true si l'une ou l'autre est $true.

if ( $age -le 13 -or $age -ge 55 )

Tout comme avec l'opérateur -and, l'évaluation se produit de gauche à droite. Sauf que si la première partie est $true, l’instruction entière est $true et ne traite pas le reste de l’expression.

Notez également le fonctionnement de la syntaxe pour ces opérateurs. Vous avez besoin de deux expressions distinctes. J’ai vu des utilisateurs essayer de faire quelque chose comme ça $value -eq 5 -or 6 sans se rendre compte de leur erreur.

-xor exclusif ou

Celui-ci est un peu inhabituel. -xorautorise une seule expression à s'évaluer en $true. Par conséquent, si les deux éléments sont $false ou si les deux éléments sont $true, alors l'expression entière est $false. Une autre façon de regarder cela est que l’expression est uniquement $true lorsque les résultats de l’expression sont différents.

Il est rare que quelqu’un utilise jamais cet opérateur logique et je ne peux pas penser à un bon exemple quant à la raison pour laquelle je l’utiliserais jamais.

Opérateurs de bits

Les opérateurs bit à bit effectuent des calculs sur les bits au sein des valeurs et produisent une nouvelle valeur comme résultat. L’enseignement des opérateurs au niveau du bit dépasse la portée de cet article, mais voici la liste d’entre eux.

-band binaire ET
-bor OU binaire
-bxor OU exclusif binaire
-bnot NON binaire
-shl décaler vers la gauche
-shr maj vers la droite

Expressions dans PowerShell

Nous pouvons utiliser PowerShell en mode standard à l’intérieur de l’instruction conditionnelle.

if ( Test-Path -Path $Path )

Test-Path retourne $true ou $false lorsqu’il s’exécute. Cela s’applique également aux commandes qui retournent d’autres valeurs.

if ( Get-Process Notepad* )

Il prend la $true valeur s’il existe un processus retourné et $false s’il n’y en a pas. Il est parfaitement valide d’utiliser des expressions de pipeline ou d’autres instructions PowerShell comme suit :

if ( Get-Process | where Name -EQ Notepad )

Ces expressions peuvent être combinées entre elles avec les opérateurs -and et -or, mais vous devrez peut-être utiliser des parenthèses pour les décomposer en sous-expressions.

if ( (Get-Process) -and (Get-Service) )

Vérification de $null

L’absence de résultat ou bien une valeur $null est évaluée à $false dans l’instruction if. Lorsque vous vérifiez spécifiquement $null, il est recommandé de placer le $null côté gauche.

if ( $null -eq $value )

Il existe plusieurs nuances lors de la gestion $null des valeurs dans PowerShell. Si vous êtes intéressé par la plongée plus profonde, j’ai un article sur tout ce que vous vouliez savoir sur $null.

Affectation de variable dans la condition

J'ai presque oublié d'ajouter celui-ci jusqu'à ce que Prasoon Karunan V me le rappelle.

if ($process=Get-Process notepad -ErrorAction Ignore) {$process} else {$false}

Normalement, lorsque vous affectez une valeur à une variable, la valeur n’est pas transmise au pipeline ou à la console. Lorsque vous effectuez une affectation de variable dans une sous-expression, elle est transmise au pipeline.

PS> $first = 1
PS> ($second = 2)
2

Découvrez comment l’affectation $first n’a pas de sortie alors que l’affectation $second en a. Lorsqu’une affectation est effectuée dans une if instruction, elle s’exécute comme l’affectation $second ci-dessus. Voici un exemple propre sur la façon dont vous pouvez l’utiliser :

if ( $process = Get-Process Notepad* )
{
    $process | Stop-Process
}

Si une valeur est attribuée à $process, alors $true l'instruction est exécutée et $process s'arrête.

Assurez-vous que vous ne confondez pas cela avec -eq car ce n’est pas une vérification d’égalité. Il s’agit d’une fonctionnalité plus obscure que la plupart des gens ne réalisent pas fonctionne de cette façon.

Affectation de variable à partir du bloc d’instructions

Vous pouvez également utiliser le if bloc d’instructions pour affecter une valeur à une variable.

$discount = if ( $age -ge 55 )
{
    Get-SeniorDiscount
}
elseif ( $age -le 13 )
{
    Get-ChildDiscount
}
else
{
    0.00
}

Chaque bloc de script écrit les résultats des commandes, ou la valeur, en tant que sortie. Nous pouvons affecter le résultat de l’instruction if à la $discount variable. Cet exemple peut avoir tout aussi facilement affecté ces valeurs à la $discount variable directement dans chaque bloc d’instructions. Je ne peux pas dire que je l’utilise souvent avec l’affirmation if , mais j’ai un exemple où j’ai utilisé cela récemment.

Chemin d’exécution alternatif

L’instruction if vous permet de spécifier une action non seulement lorsque l’instruction est $true, mais également pour le moment où elle est $false. C’est là que l’instruction else entre en jeu.

autre

L’instruction else est toujours la dernière partie de l’instruction if lorsqu’elle est utilisée.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
else
{
    Write-Warning "$path doesn't exist or isn't a file."
}

Dans cet exemple, nous vérifions le $path pour s’assurer qu’il s’agit d’un fichier. Si nous trouvons le fichier, nous le déplacerons. Sinon, nous écrivons un avertissement. Ce type de logique de branchement est très courant.

Imbriqué si

Les instructions if et else acceptent un bloc de script, ce qui nous permet de placer n’importe quelle commande PowerShell dedans, y compris une autre instruction if. Cela vous permet d’utiliser une logique beaucoup plus complexe.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
else
{
    if ( Test-Path -Path $Path )
    {
        Write-Warning "A file was required but a directory was found instead."
    }
    else
    {
        Write-Warning "$path could not be found."
    }
}

Dans cet exemple, nous testons d’abord le chemin heureux, puis prenons des mesures dessus. En cas d’échec, nous effectuons une autre vérification et fournissons des informations plus détaillées à l’utilisateur.

Elseif

Nous ne sommes pas limités à un seul contrôle conditionnel. Nous pouvons chaîner les instructions if et else ensemble au lieu de les imbriquer, en utilisant l'instruction elseif.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
elseif ( Test-Path -Path $Path )
{
    Write-Warning "A file was required but a directory was found instead."
}
else
{
    Write-Warning "$path could not be found."
}

L’exécution se produit du haut au bas. L’instruction supérieure if est évaluée en premier. Si c’est $falsele cas, il descend vers le bas vers le suivant elseif ou else dans la liste. Cette dernière else est l’action par défaut à entreprendre si aucun des autres ne retourne $true.

switch

À ce stade, je dois mentionner l’affirmation switch . Il fournit une autre syntaxe pour effectuer plusieurs comparaisons avec une valeur. Avec le switch, vous spécifiez une expression et ce résultat est comparé à plusieurs valeurs différentes. Si l’une de ces valeurs correspond, le bloc de code correspondant est exécuté. Examinez cet exemple :

$itemType = 'Role'
switch ( $itemType )
{
    'Component'
    {
        'is a component'
    }
    'Role'
    {
        'is a role'
    }
    'Location'
    {
        'is a location'
    }
}

Il y a trois valeurs possibles qui peuvent correspondre au $itemType. Dans ce cas, il correspond à Role. J’ai utilisé un exemple simple pour vous donner une exposition à l’opérateur switch . Je parle plus de tout ce que vous avez jamais voulu savoir sur l’instruction switch dans un autre article.

Tableau en ligne

J’ai une fonction appelée Invoke-SnowSql qui lance un exécutable avec plusieurs arguments de ligne de commande. Voici un clip de cette fonction où je crée le tableau d’arguments.

$snowSqlParam = @(
    '--accountname', $Endpoint
    '--username', $Credential.UserName
    '--option', 'exit_on_error=true'
    '--option', 'output_format=csv'
    '--option', 'friendly=false'
    '--option', 'timing=false'
    if ($Debug)
    {
        '--option', 'log_level=DEBUG'
    }
    if ($Path)
    {
        '--filename', $Path
    }
    else
    {
        '--query', $singleLineQuery
    }
)

Les variables $Debug et $Path sont des paramètres de la fonction fournis par l’utilisateur final. J'évalue ces éléments en ligne dans l'initialisation de mon tableau. Si $Debug c’est vrai, ces valeurs tombent dans le $snowSqlParam bon endroit. Il en va de même pour la $Path variable.

Simplifier les opérations complexes

Il est inévitable que vous rencontriez une situation qui a beaucoup trop de comparaisons à vérifier et votre if instruction défile bien au-delà à droite de l’écran.

$user = Get-ADUser -Identity $UserName
if ( $null -ne $user -and $user.Department -eq 'Finance' -and $user.Title -match 'Senior' -and $user.HomeDrive -notlike '\\server\*' )
{
    # Do Something
}

Ils peuvent être difficiles à lire et qui vous rendent plus enclin à faire des erreurs. Il y a quelques choses que nous pouvons faire à ce sujet.

Continuation de ligne

Certains opérateurs dans PowerShell vous permettent d’encapsuler la commande à la ligne suivante. Les opérateurs logiques -and et -or sont utiles si vous souhaitez diviser votre expression en plusieurs lignes.

if ($null -ne $user -and
    $user.Department -eq 'Finance' -and
    $user.Title -match 'Senior' -and
    $user.HomeDrive -notlike '\\server\*'
)
{
    # Do Something
}

Il se passe encore beaucoup de choses là, mais placer chaque élément sur une ligne distincte fait une grande différence. Je l’utilise généralement lorsque j’obtiens plus de deux comparaisons ou si je dois faire défiler vers la droite pour lire l’une des logiques.

Pré-calcul des résultats

Nous pouvons extraire cette instruction de l’instruction if et vérifier uniquement le résultat.

$needsSecureHomeDrive = $null -ne $user -and
    $user.Department -eq 'Finance' -and
    $user.Title -match 'Senior' -and
    $user.HomeDrive -notlike '\\server\*'

if ( $needsSecureHomeDrive )
{
    # Do Something
}

Cela se sent juste beaucoup plus propre que l’exemple précédent. Vous avez également la possibilité d’utiliser un nom de variable qui explique vraiment ce que vous vérifiez. Il s’agit également d’un exemple de code auto-documentant qui enregistre des commentaires inutiles.

Instructions if multiples

Nous pouvons diviser cela en plusieurs déclarations et les vérifier une par une. Dans ce cas, nous utilisons un indicateur ou une variable de suivi pour combiner les résultats.


$skipUser = $false

if( $null -eq $user )
{
    $skipUser = $true
}

if( $user.Department -ne 'Finance' )
{
    Write-Verbose "isn't in Finance department"
    $skipUser = $true
}

if( $user.Title -match 'Senior' )
{
    Write-Verbose "Doesn't have Senior title"
    $skipUser = $true
}

if( $user.HomeDrive -like '\\server\*' )
{
    Write-Verbose "Home drive already configured"
    $skipUser = $true
}

if ( -not $skipUser )
{
    # do something
}

J'ai dû inverser la logique pour que le système d'indicateur fonctionne correctement. Chaque évaluation est une déclaration individuelle if. L’avantage est que lorsque vous déboguez, vous pouvez savoir exactement ce que fait la logique. J'ai pu ajouter une bien meilleure verbosité simultanément.

L’inconvénient évident est que c’est beaucoup plus de code à écrire. Le code est plus complexe à examiner, car il prend une seule ligne de logique et l’explose en 25 lignes ou plus.

Utilisation des fonctions

Nous pouvons également déplacer toutes ces logiques de validation dans une fonction. Voyez comme c'est propre à première vue.

if ( Test-SecureDriveConfiguration -ADUser $user )
{
    # do something
}

Vous devez toujours créer la fonction pour effectuer la validation, mais cela facilite grandement l’utilisation de ce code. Il facilite le test de ce code. Dans vos tests, vous pouvez simuler l’appel à Test-ADDriveConfiguration et vous n’avez besoin que de deux tests pour cette fonction. Un cas où il renvoie $true et un cas où il renvoie $false. Le test de l’autre fonction est plus simple, car il est si petit.

Le corps de cette fonction peut toujours être celui d’un one-liner avec lequel nous avons commencé ou de la logique développée que nous avons utilisée dans la dernière section. Cela fonctionne bien pour les deux scénarios et vous permet de modifier facilement cette implémentation ultérieurement.

Gestion des erreurs

L’une des principales utilisations de l’instruction if consiste à vérifier les conditions d’erreur avant de rencontrer des erreurs. Un bon exemple consiste à vérifier si un dossier existe déjà avant de tenter de le créer.

if ( -not (Test-Path -Path $folder) )
{
    New-Item -Type Directory -Path $folder
}

J’aime dire que si vous attendez une exception, alors ce n’est pas vraiment une exception. Vérifiez donc vos valeurs et validez vos conditions dans lesquelles vous pouvez.

Si vous voulez plonger un peu plus dans la gestion des exceptions réelles, j’ai un article sur tout ce que vous avez jamais voulu savoir sur les exceptions.

Mots finaux

L’instruction if est une instruction aussi simple, mais elle est un élément fondamental de PowerShell. Vous vous retrouverez à utiliser ceci de nombreuses fois dans presque tous les scripts que vous écrivez. J’espère que vous avez une meilleure compréhension qu’auparavant.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-04-10

Tout ce que vous vouliez savoir sur l’instruction if

Exécution conditionnelle

L’instruction if.

Opérateurs de comparaison

-eq pour l’égalité

-ne pas égal

-gt pour supérieur à, -ge pour supérieur ou égal à, -lt pour inférieur à, -le pour inférieur ou égal à

correspondances similaires à des caractères génériques

-correspond à l’expression régulière

-est de type

Opérateurs de collection

-Contient

-in

Opérateurs logiques

-Pas

! opérateur

-et

-Ou

-xor exclusif ou

Opérateurs de bits

Expressions dans PowerShell

Vérification de $null

Affectation de variable dans la condition

Affectation de variable à partir du bloc d’instructions

Chemin d’exécution alternatif

autre

Imbriqué si

Elseif

switch

Tableau en ligne

Simplifier les opérations complexes

Continuation de ligne

Pré-calcul des résultats

Instructions if multiples

Utilisation des fonctions

Gestion des erreurs

Mots finaux

Commentaires

Ressources supplémentaires

Tout ce que vous vouliez savoir sur l’instruction `if`

L’instruction `if`.