Partager via

about_Switch

  • Article

Description courte

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

Description longue

Pour vérifier une condition dans un script ou une fonction, utilisez 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, utilisez une switch instruction. L’instruction switch équivaut à une série d’instructions if , mais elle est plus simple. L’instruction switch répertorie chaque condition et une action facultative. Si une condition est obtenue, l’action est effectuée.

L’instruction switch peut utiliser les variables automatiques et $switch les $_ variables. Pour plus d’informations, consultez about_Automatic_Variables.

Syntaxe

Une instruction de base switch a le format suivant :

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

Les instructions équivalentes if sont les suivantes :

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

Il <test-expression> s’agit d’une expression unique évaluée en mode expression pour retourner une valeur.

Il <result-to-be-matched> s’agit d’une expression dont la valeur est comparée à la valeur d’entrée. Les expressions incluent des valeurs littérales (chaînes ou nombres), des variables et des blocs de script qui retournent une valeur booléenne.

Toute valeur non mise en guillemet qui n’est pas reconnue comme un nombre est traitée comme une chaîne. Pour éviter toute confusion ou conversion involontaire de chaînes, vous devez toujours citer des valeurs de chaîne. Placez toutes les expressions entre parenthèses (), en créant des sous-expressions, pour vous assurer que l’expression est évaluée correctement.

Il est important de comprendre que la <result-to-be-matched> valeur se trouve sur le côté gauche de l’expression de comparaison. Cela signifie que le résultat de l’opération <test-expression> se trouve sur le côté droit, qui peut être converti en type de la valeur de gauche pour la comparaison. Pour plus d’informations, consultez about_Comparison_Operators

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

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.

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
}

or

switch [-regex | -wildcard | -exact] [-casesensitive] -file filename
{
    "string" | number | variable | { <value-scriptblock> } { <action-scriptblock> }
    default { <action-scriptblock> }  # optional
}

Si aucun paramètre n’est utilisé, 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 default clause est déclenchée lorsque la valeur ne correspond à aucune des conditions. Il équivaut à une else clause dans une if instruction. 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 l’entrée à partir d’un fichier plutôt qu’un <test-expression>fichier . Si plusieurs paramètres de fichier sont inclus, seul le dernier est utilisé. Chaque ligne du fichier est lue et évaluée par l’instruction switch . La comparaison respecte la casse.
  • 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.

Remarque

Lorsque vous spécifiez des valeurs en conflit, telles que Regex et Wildcard, le dernier paramètre spécifié est prioritaire et tous les paramètres en conflit sont ignorés. Plusieurs instances de paramètres sont également autorisées. Toutefois, seul le dernier paramètre répertorié est utilisé.

Exemples

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 is one."}
    2 {"It is two."}
    3 {"It is three."}
    4 {"It is four."}
}

It is three.

Dans cet exemple simple, la valeur est comparée à chaque condition de la liste, même s’il existe une correspondance pour la valeur 3. L’instruction suivante switch présente deux conditions pour une valeur de 3. Il montre que, par défaut, toutes les conditions sont testées.

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

It is three.
Three again.

Pour diriger la switch comparaison après une correspondance, utilisez l’instruction break . L’instruction break met fin à l’instruction switch .

switch (3)
{
    1 {"It is one."}
    2 {"It is two."}
    3 {"It is three."; Break}
    4 {"It is four."}
    3 {"Three again."}
}

It is three.

Si la valeur de test est une collection, telle qu’un tableau, chaque élément de la collection est évalué dans l’ordre dans lequel il apparaît. Les exemples suivants évaluent 4, puis 2.

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

It is four.
It is two.

Toutes les break instructions s’appliquent à la collection, et non à chaque valeur, comme illustré dans l’exemple suivant. L’instruction switch est arrêtée par l’instruction break dans la condition de valeur 4.

switch (4, 2)
{
    1 {"It is one."; Break}
    2 {"It is two." ; Break }
    3 {"It is three." ; Break }
    4 {"It is four." ; Break }
    3 {"Three again."}
}

It is four.

Dans cet exemple, l’instruction switch teste le type de la valeur dans la table de hachage. Vous devez utiliser et expression qui retourne une valeur booléenne pour sélectionner le scriptblock à 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

Dans cet exemple, un objet qui n’est pas une chaîne ou des données numériques est transmis au switch. Effectue switch une contrainte de chaîne sur l’objet et évalue le résultat.

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

$test.ToString()

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

System.Collections.Hashtable
Hashtable string coercion

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

switch ("fourteen")
{
    1 {"It is one."; Break}
    2 {"It is two."; Break}
    3 {"It is three."; Break}
    4 {"It is 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 is one."; Break}
    2 {"It is two."; Break}
    3 {"It is three."; Break}
    4 {"It is four."; Break}
    "fo*" {"That's too many."}
    Default {
        "No matches"
    }
}

No matches

Pour que le mot « quatorze » corresponde à un cas, vous devez utiliser le ou -Regex le -Wildcard paramètre.

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

That's too many.

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!' }
}

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 continue les break 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

Voir aussi