Type-Switch

Ein Typschalter unterscheidet zwischen mehreren möglichen Typen einer Schnittstellenwert. Es ist die Verallgemeinerung von comma ok, wenn es welche gibt mehr als ein Fall.

Syntax

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) ist eine spezielle Syntax, die NUR innerhalb von switch gültig ist.
• v := ... bindet den Wert an den Typ des aktuellen Falls: Innerhalb von case int hat v den Typ int.
• default fängt alle anderen Typen ab; dort hat v den Typ der Originalschnittstelle.
• case nil gleicht die Schnittstelle mit einem dynamischen Nulltyp ab.

„Namenloser“ Fall

Wenn Sie den eingegebenen Wert nicht benötigen, können Sie v weglassen:

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

Ein Formular, das verwendet wird, wenn Sie nur den Typ unterscheiden und nicht ausführen müssen auf den Wert.

Mehrere Typen im selben Fall

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)
}

Typischer Anwendungsfall: formatiertes Drucken

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 selbst verwendet intern einen Typschalter, um das zu verarbeiten Standardformate.

Typschalter vs. Reflexion

Für einige bekannte Typen → Typschalter (schnell, lesbar). Zur dynamischen Inspektion unbekannter Typen → das reflect-Paket (mehr kraftvoll, aber langsamer und ausführlicher).

Probieren Sie es aus

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

Zusammenfassung

• switch v := i.(type) { case T: ... }: unterscheidet den dynamischen Typ. – In einem Einzeltyp-Fall enthält v den Typ des Falles.
• case T1, T2: v behält den Typ der ursprünglichen Schnittstelle bei.
• default für nicht bearbeitete Fälle; case nil für die Null-Schnittstelle.
• Kein fallthrough in Typschaltern.
• 1 Typ → Typzusicherung; 2+ Typen → Typschalter.