Conditions `switch` en

À propos de Conditions `switch`

Une instruction switch évalue une expression et exécute le premier case dont la valeur correspond. C'est souvent une alternative plus propre aux longues chaînes de if ... else if.

Utilisation de base

operatingSystem := "windows"

switch operatingSystem {
case "windows":
    // do something if the operating system is windows
case "linux":
    // do something if the operating system is linux
case "macos":
    // do something if the operating system is macos
default:
    // do something if the operating system is none of the above
}

Plusieurs valeurs peuvent être regroupées dans un seul case à l'aide d'une virgule. Le case correspond si l'expression est égale à l'une d'entre elles :

switch operatingSystem {
case "windows", "linux":
    // do something if the operating system is windows or linux
case "macos":
    // do something if the operating system is macos
default:
    // do something if the operating system is none of the above
}

Le switch sans expression

L'expression qui suit switch peut aussi être omise entièrement. Chaque case contient alors une expression booléenne, et le premier qui vaut true est exécuté.

age := 21

switch {
case age > 20 && age < 30:
    // do something if age is between 20 and 30
case age == 10:
    // do something if age is equal to 10
default:
    // do something else for every other case
}

Instruction d'initialisation

Comme if, un switch peut inclure une courte instruction d'initialisation avant l'expression. Les variables qui y sont déclarées ont pour portée le bloc du switch :

switch v := getValue(); {
case v < 0:
    // do something if v is less than 0
case v == 0:
    // do something if v is 0
default:
    // do something else for every other case
}
// v will not be accessible here

fallthrough

fallthrough fait exécuter le corps du case suivant, que son expression corresponde ou non. Il doit être la dernière instruction du corps du case, et il doit y avoir un case suivant à exécuter.

fallthrough est rare dans le Go idiomatique, car il rend les case adjacents dépendants les uns des autres. Il est donc plus difficile de raisonner sur les case isolément, ce qui rend le switch plus difficile à lire. Quand des case doivent avoir le même comportement, les regrouper à l'aide d'une virgule est plus clair. Quand la logique est partagée entre plusieurs case pour d'autres raisons, envisage d'extraire cette logique commune dans une fonction auxiliaire.

s := "hello"

switch s {
case "hello":
    fmt.Println("hello")
    fallthrough
case "world":
    fmt.Println("world") // also runs, even though s != "world"
}
// Output:
// hello
// world

Pour en savoir plus, consulte Go by Example: Switch ou la spécification du langage Go.