Idiomatisches switch

Der switch von Go ist ergonomischer als der von C/Java: Jeder case hat seinen eigenen Eigener impliziter Block (kein break zum Schreiben), den Sie gruppieren können mehrere Werte mit einem Komma und ein switch ohne Ausdruck verhält sich wie eine besser lesbare if/else if-Kette.

Einen Wert einschalten

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

case akzeptiert mehrere durch Kommas getrennte Werte und es gibt keine impliziten Werte Fallthrough: Sobald ein Fall ausgeführt wird, wird der Schalter beendet.

Ohne Bedingung wechseln

Wenn Sie den Ausdruck weglassen, wertet der Schalter true aus und jeder case ist ein bool-Bedingung. Es ist die idiomatische Alternative zu langen if/else if-Ketten:

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

Init-Anweisung

Wie if akzeptiert auch switch eine Init-Anweisung:

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

n existiert nur innerhalb des Switches.

Expliziter fallthrough

Wenn Sie wirklich möchten, dass die Hinrichtung in den nächsten Fall fällt, müssen Sie Folgendes schreiben:

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

Typschalter (Vorschau)

Damit können Sie anhand des dynamischen Typs einer Schnittstelle unterscheiden Wert. Wir werden es im Modul „Schnittstellen“ ausführlich behandeln:

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

Probieren Sie es aus

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

Zusammenfassung

• case akzeptiert mehrere durch Kommas getrennte Werte.
• Kein impliziter Fallthrough: Jeder Fall hat seinen eigenen impliziten break.
• switch { ... } ohne Ausdruck = eine besser lesbare if/else if-Kette.
• Init-Anweisung: switch x := f(); { ... }, Gültigkeitsbereich auf den Block beschränkt.
• fallthrough existiert, ist aber selten; geht in den nächsten Fall, OHNE dessen Zustand auszuwerten.
• Typschalter v := i.(type) zur Unterscheidung basierend auf dem dynamischen Typ (Schnittstellenmodul).