Type switch

Un commutateur de type fait la distinction entre plusieurs types possibles d'un valeur de l'interface. C'est la généralisation de comma ok quand il y a plus d'un cas.

Syntaxe

func describe(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("int %d", v)
    case string:
        return fmt.Sprintf("string %q", v)
    case nil:
        return "nil"
    default:
        return fmt.Sprintf("altro tipo: %T", v)
    }
}

• i.(type) est une syntaxe spéciale, valable UNIQUEMENT dans switch.
• v := ... lie la valeur au type du cas courant : à l'intérieur de case int, v a le type int.
• default capture tous les autres types ; là, v a le type de l'interface d'origine.
• case nil fait correspondre l'interface avec un type dynamique nul.

Cas "Sans nom"

Si vous n'avez pas besoin de la valeur saisie, vous pouvez omettre le v :

switch i.(type) {
case int:
    // you know it's an int, but you don't have a variable of that type
case string:
    // ...
}

Un formulaire utilisé lorsqu'il vous suffit de distinguer le type, pas d'opérer sur la valeur.

Plusieurs types dans le même cas

switch v := i.(type) {
case int, int64:
    // here v is still interface{}: the "common" type is just the interface
    fmt.Println("numero intero:", v)
case string:
    // here v is string
    fmt.Println("stringa:", v)
}

Cas d'utilisation typique : impression formatée

func print(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("%d\n", v)
    case string:
        fmt.Printf("%s\n", v)
    case fmt.Stringer:
        fmt.Println(v.String())
    default:
        fmt.Printf("%v\n", v)
    }
}

fmt.Println lui-même utilise un commutateur de type en interne pour gérer le formats standards.

Type de commutateur vs réflexion

Pour quelques types connus → tapez switch (rapide, lisible). Pour l'inspection dynamique de types inconnus → le package reflect (plus puissant mais plus lent et plus verbeux).

Essayez-le

switch ??? {
  case int: ...
}

Récapitulatif

• switch v := i.(type) { case T: ... } : discrimine sur le type dynamique.
• A l'intérieur d'un boîtier monotype, v possède le type du boîtier.
• case T1, T2 : v conserve le type de l'interface d'origine.
• default pour les dossiers non traités ; case nil pour l'interface nulle.
• Pas de fallthrough dans les interrupteurs de type.
• 1 type → assertion de type ; 2+ types → commutateur de type.