À propos de Switch

Brève description

Explique comment utiliser un commutateur pour gérer plusieurs instructions conditionnelles.

Description longue

Pour vérifier une condition dans un script ou une fonction, vous pouvez utiliser une if instruction. L’instruction if peut vérifier de nombreux types de conditions, y compris la valeur des variables et les propriétés des objets.

Pour vérifier plusieurs conditions, vous pouvez utiliser une switch instruction. L’instruction switch est similaire à une série d’instructions if , mais c’est plus simple. L’instruction switch répertorie chaque condition et l’action correspondante. Si une condition correspond, l’action est effectuée.

Syntaxe

Une instruction de base switch a le format suivant :

switch (<test-expression>) {
    <result1-to-be-matched> {<action>}
    <result2-to-be-matched> {<action>}
}

La syntaxe d’une switch instruction est similaire aux instructions suivantes if :

if ("$(<result1-to-be-matched>)") -eq ("$(<test-expression>)") {<action>}
if ("$(<result2-to-be-matched>)") -eq ("$(<test-expression>)") {<action>}

Les expressions incluent des valeurs littérales (chaînes ou nombres), des variables et des blocs de script qui retournent une valeur booléenne. L’instruction switch convertit toutes les valeurs en chaînes avant la comparaison. Pour obtenir un exemple, consultez Impact de la conversion de chaîne plus loin dans cet article.

L’objet <test-expression> est évalué en mode expression. Si l’expression retourne plusieurs valeurs, telles qu’un tableau ou un autre type énumérable, l’instruction switch évalue chaque valeur énumérée séparément.

Il <result-to-be-matched> s’agit d’une expression qui doit être résolue en une seule valeur. Cette valeur est comparée à la valeur d’entrée.

La valeur default est réservée à l’action utilisée lorsqu’il n’y a aucune autre correspondance.

L’instruction switch peut utiliser les variables automatiques et $_ les $switch variables. La variable automatique contient la valeur de l’expression passée à l’instruction switch et est disponible pour l’évaluation et l’utilisation dans l’étendue des <result-to-be-matched> instructions. Pour plus d’informations, consultez about_Automatic_Variables.

La syntaxe complète switch de l’instruction est la suivante :

switch [-Regex | -Wildcard | -Exact] [-CaseSensitive] (<test-expression>) {
    string | number | variable | { <value-scriptblock> }
        { <action-scriptblock> }
    default { <action-scriptblock> } # optional
}

ou

switch [-Regex | -Wildcard | -Exact] [-CaseSensitive] -File filename {
    string | number | variable | { <value-scriptblock> }
        { <action-scriptblock> }
    default { <action-scriptblock> }  # optional
}

Si vous n’utilisez pas de paramètres, switch se comporte de la même façon que l’utilisation du paramètre Exact. Il effectue une correspondance sans respect de la casse pour la valeur. Si la valeur est une collection, chaque élément est évalué dans l’ordre dans lequel il apparaît.

L’instruction switch doit inclure au moins une instruction de condition.

La clause default est déclenchée lorsque la valeur ne correspond à aucune des conditions. Il équivaut à une clause else dans une instruction if. default Une seule clause est autorisée dans chaque switch instruction.

switch a les paramètres suivants :

• Caractère générique : indique que la condition est une chaîne générique. Si la clause match n’est pas une chaîne, le paramètre est ignoré. La comparaison respecte la casse.
• Exact : indique que la clause match, s’il s’agit d’une chaîne, doit correspondre exactement. Si la clause match n’est pas une chaîne, ce paramètre est ignoré. La comparaison respecte la casse.
• Respect de la casse : effectue une correspondance sensible à la casse. Si la clause match n’est pas une chaîne, ce paramètre est ignoré.
• fichier : prend une entrée à partir d’un fichier plutôt qu’un <test-expression>. Le fichier lit une ligne à la fois et est évalué par l’instruction switch. Par défaut, la comparaison ne respecte pas la casse. Le paramètre File ne prend en charge qu’un seul fichier. Si plusieurs paramètres de fichier sont inclus, seul le dernier est utilisé. Pour plus d’informations, consultez les exemples de paramètres de fichier.
• Regex : effectue la correspondance d’expression régulière de la valeur à la condition. Si la clause match n’est pas une chaîne, ce paramètre est ignoré. La comparaison respecte la casse. La $Matches variable automatique est disponible pour une utilisation dans le bloc d’instructions correspondant.

Examples

Les exemples suivants illustrent l’utilisation de l’instruction switch .

Exemples de correspondances simples

Dans l’exemple suivant, l’instruction switch compare la valeur de test 3 à chacune des conditions. Lorsque la valeur de test correspond à la condition, l’action est effectuée.

switch (3) {
    1 { "It's one."   }
    2 { "It's two."   }
    3 { "It's three." }
    4 { "It's four."  }
}

It's three.

Dans cet exemple, la valeur est comparée à chaque condition de la liste. L’instruction switch suivante a deux conditions pour une valeur de 3, ce qui montre que toutes les conditions sont testées.

switch (3) {
    1 { "It's one."    }
    2 { "It's two."    }
    3 { "It's three."  }
    4 { "It's four."   }
    3 { "Three again." }
}

It's three.
Three again.

Utiliser break et continue contrôler le flux

Si la valeur correspond à plusieurs conditions, l’action de chaque condition est exécutée. Pour modifier ce comportement, utilisez les mots clés ou break les continue mots clés.

Le break mot clé arrête le traitement et quitte l’instruction switch .

Le continue mot clé cesse de traiter la valeur actuelle, mais continue de traiter les valeurs suivantes.

L’exemple suivant traite un tableau de nombres et s’affiche s’ils sont impairs ou pairs. Les nombres négatifs sont ignorés avec le continue mot clé. Si un nombre non-nombre est rencontré, l’exécution est arrêtée avec le break mot clé.

switch (1,4,-1,3,"Hello",2,1) {
    {$_ -lt 0}           { continue }
    {$_ -isnot [int32]}  { break }
    {$_ % 2}             { "$_ is Odd" }
    {-not ($_ % 2)}      { "$_ is Even" }
}

1 is Odd
4 is Even
3 is Odd

Impact de la conversion de chaînes

Toutes les valeurs, à la fois les entrées et la valeur de comparaison, sont converties en chaînes pour la comparaison. Pour éviter une conversion de chaîne involontaire, utilisez des blocs de script pour évaluer la valeur du commutateur.

switch ( ([datetime]'1 Jan 1970').DayOfWeek ) {
    4            { 'The integer value matches a Thursday.' }
    "4"          { 'The numeric string matches a Thursday.' }
    "Thursday"   { 'The string value matches a Thursday.' }
    { 4 -eq $_ } { 'The expression matches a Thursday.' }
}

La propriété DayOfWeek de l’objet date est une énumération. Bien que les énumérations puissent être comparées à leurs valeurs numériques ou de chaînes, l’instruction switch convertit la valeur en une représentation sous forme de chaîne de l’énumération.

The string value matches a Thursday.
The expression matches a Thursday.

Ce comportement est différent du comportement de la -eq comparaison dans une if instruction.

if (4 -eq ([datetime]'1 Jan 1970').DayOfWeek) {
    'The integer value matches a Thursday.'
}

The value matches a Thursday.

Dans cet exemple, une table de hachage est passée à l’instruction switch . Convertit switch la table de hachage en chaîne.

$test = @{
    Test  = 'test'
    Test2 = 'test2'
}

$test.ToString()

System.Collections.Hashtable

Notez que la représentation sous forme de chaîne de la table de hachage n’est pas la même que la valeur de la clé de test .

switch -Exact ($test) {
    'System.Collections.Hashtable' { 'Hashtable string coercion' }
    'test'                         { 'Hashtable value' }
}

Hashtable string coercion

Permet switch de tester les valeurs dans une table de hachage

Dans cet exemple, l’instruction switch teste le type de la valeur dans la table de hachage. Nous devons énumérer les éléments de la table de hachage avant de pouvoir tester les valeurs. Pour éviter les complications de la conversion de chaîne, utilisez un bloc de script qui retourne une valeur booléenne pour sélectionner le script d’action à exécuter.

$var = @{A = 10; B = 'abc'}

foreach ($key in $var.Keys) {
    switch ($var[$key].GetType()) {
        { $_ -eq [int32]  }  { "$key + 10 = $($var[$key] + 10)" }
        { $_ -eq [string] }  { "$key = $($var[$key])"           }
    }
}

A + 10 = 20
B = abc

Utiliser des caractères génériques avec switch

Dans cet exemple, il n’y a pas de cas correspondant afin qu’il n’y ait pas de sortie.

switch ("fourteen") {
    1     { "It's one.";   break }
    2     { "It's two.";   break }
    3     { "It's three."; break }
    4     { "It's four.";  break }
    "fo*" { "That's too many."   }
}

En ajoutant la default clause, vous pouvez effectuer une action quand aucune autre condition ne réussit.

switch ("fourteen") {
    1       { "It's one.";   break }
    2       { "It's two.";   break }
    3       { "It's three."; break }
    4       { "It's four.";  break }
    "fo*"   { "That's too many."   }
    default { "No matches"         }
}

No matches

Pour que le mot fourteen correspondre à un cas, vous devez utiliser le paramètre -Wildcard ou -Regex.

switch -Wildcard ("fourteen") {
    1     { "It's one.";   break }
    2     { "It's two.";   break }
    3     { "It's three."; break }
    4     { "It's four.";  break }
    "fo*" { "That's too many."   }
}

That's too many.

Utiliser des expressions régulières avec switch

L’exemple suivant utilise le -Regex paramètre.

$target = 'https://bing.com'
switch -Regex ($target) {
    '^ftp\://.*$'
        {
            "$_ is an ftp address"
            break
        }
    '^\w+@\w+\.com|edu|org$'
        {
            "$_ is an email address"
            break
        }
    '^(http[s]?)\://.*$'
        {
            "$_ is a web address that uses $($Matches[1])"
            break
        }
}

https://bing.com is a web address that uses https

L’exemple suivant illustre l’utilisation de blocs de script en tant que switch conditions d’instruction.

switch ("Test") {
    { $_ -is [string] } { "Found a string" }
    "Test"              { "This $_ executes as well" }
}

Found a string
This Test executes as well

L’exemple suivant traite un tableau contenant deux valeurs de date. Compare <value-scriptblock> la propriété Year de chaque date. Le <action-scriptblock> message d’accueil affiche un message de bienvenue ou le nombre de jours jusqu’au début de l’année 2022.

switch ((Get-Date 1-Jan-2022), (Get-Date 25-Dec-2021)) {
    { $_.Year -eq 2021 }
        {
            $days = ((Get-Date 1/1/2022) - $_).Days
            "There are $days days until 2022."
        }
    { $_.Year -eq 2022 } { 'Welcome to 2022!' }
}

Lire le contenu d’un fichier avec switch

L’utilisation de l’instruction switch avec le paramètre File est un moyen efficace de traiter les fichiers volumineux ligne par ligne. PowerShell diffuse les lignes du fichier vers l’instruction switch. Chaque ligne est traitée individuellement.

Vous pouvez terminer le traitement avant d’atteindre la fin du fichier à l’aide du mot clé break dans l’instruction d’action. L’instruction switch est plus efficace que d’utiliser Get-Content pour traiter les fichiers volumineux ligne par ligne.

Vous pouvez combiner switch -File avec -Wildcard ou -Regex pour une correspondance de modèle ligne par ligne flexible et efficace.

L’exemple suivant lit le README.md dans le référentiel PowerShell-Docs. Il génère chaque ligne jusqu’à ce qu’elle atteigne la ligne qui commence par ##.

switch -Regex -File .\README.md {
    '^##\s' { break }
    default { $_; continue }
}

L’argument <filename> accepte des expressions génériques, mais il doit correspondre à un seul fichier. L’exemple suivant est le même que celui précédent, sauf qu’il utilise un caractère générique dans l’argument <filename>. Cet exemple fonctionne, car le modèle générique ne correspond qu’à un seul fichier.

switch -Regex -File .\README.* {
    '^##\s' { break }
    default { $_; continue }
}

Vous devez placer des caractères d’échappement qui peuvent être interprétés comme des caractères génériques si vous souhaitez qu’ils soient traités comme des littéraux.

$file = (New-Item -Path 'Temp:\Foo[0]' -Value Foo -Force).FullName
switch -File $file { Foo { 'Foo' } }
# No files matching '...\Temp\Foo[0]' were found.

$fileEscaped = [WildcardPattern]::Escape($file)
switch -File $fileEscaped { foo { 'Foo' } }
# Foo

Voir aussi

• about_Break
• about_Continue
• about_If
• à_propos_des_blocs_de_scripts