Switch idiomatique

Le switch de Go est plus ergonomique que celui de C/Java : chaque case a le son bloc implicite (pas de break à écrire), ils peuvent être regroupés plusieurs valeurs avec la virgule, et un switch sans expression se comporte comme une chaîne if/else if plus lisible.

Passer à une valeur

giorno := "mar"
switch giorno {
case "lun", "mar", "mer", "gio", "ven":
    fmt.Println("feriale")
case "sab", "dom":
    fmt.Println("weekend")
default:
    fmt.Println("sconosciuto")
}

case accepte plusieurs valeurs séparées par des virgules et il n'y a pas de solution de secours implicit : dès qu'un cas est exécuté, le commutateur se termine.

Changer sans condition

Si vous omettez l'expression, le commutateur évalue true et chaque case est un état bool. C'est l'alternative idiomatique aux longues chaînes if/else if :

switch {
case x < 0:
    fmt.Println("negativo")
case x == 0:
    fmt.Println("zero")
case x < 10:
    fmt.Println("piccolo")
default:
    fmt.Println("grande")
}

Instruction d'initialisation

Comme avec if, switch accepte également une instruction init :

switch n := len(s); {
case n == 0:
    fmt.Println("vuoto")
case n > 100:
    fmt.Println("lungo")
default:
    fmt.Println("ok")
}

n existe uniquement à l’intérieur du commutateur.

fallthrough explicite

Si vous voulez vraiment que l'exécution tombe dans le cas suivant, vous devez l'écrire :

switch 1 {
case 1:
    fmt.Println("uno")
    fallthrough
case 2:
    fmt.Println("due")  // anche questo viene stampato
case 3:
    fmt.Println("tre")  // questo no
}

Type de commutateur (notion)

Vous permet de faire une discrimination en fonction du type dynamique d'une valeur interface. Nous le verrons en profondeur dans le module Interfaces :

var i interface{} = "ciao"
switch v := i.(type) {
case int:
    fmt.Println("int:", v)
case string:
    fmt.Println("string:", v)
default:
    fmt.Printf("tipo %T\n", v)
}

Essayez-le vous-même

switch 1 {
case 1:
    fmt.Print("a")
case 2:
    fmt.Print("b")
}

Récapitulatif

• case accepte plusieurs valeurs séparées par une virgule.
• Aucune solution implicite : chaque cas a son propre break implicite.
• switch { ... } sans expression = chaîne if/else if plus lisible.
• Instruction d'initialisation : switch x := f(); { ... }, portée limitée par blocs.
• fallthrough existe mais est rare ; entre ensuite dans le dossier SANS évaluer son état.
• Tapez le commutateur v := i.(type) pour discriminer en fonction du type dynamique (module Interfaces).