Idiomatische schakelaar

Go's switch is ergonomischer dan C/Java's: elke case heeft zijn eigen eigen impliciete blok (geen break om te schrijven), je kunt groeperen meerdere waarden met een komma, en een switch zonder expressie gedraagt zich zoals een beter leesbare if/else if keten.

Schakel een waarde in

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

case accepteert meerdere waarden gescheiden door komma's en er is geen impliciet fallthrough: zodra een zaak is uitgevoerd, gaat de schakelaar uit.

Overstappen zonder voorwaarde

Als u de uitdrukking weglaat, evalueert de schakelaar true en is elke case een bool voorwaarde. Het is het idiomatische alternatief voor lange if/else if ketens:

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

Init-verklaring

Net als bij if accepteert switch ook een init-instructie:

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

n bestaat alleen binnen de switch.

Expliciet fallthrough

Als je echt wilt dat de uitvoering in de volgende zaak valt, moet je dit schrijven:

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

Typeschakelaar (preview)

Hiermee kunt u onderscheid maken op basis van het dynamische type van een interface waarde. We gaan er dieper op in in de Interfaces-module:

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

Probeer het

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

Samenvatten

• case accepteert meerdere waarden gescheiden door komma's.
• Geen impliciete fallthrough: elk geval heeft zijn eigen impliciete break.
• switch { ... } zonder expressie = een beter leesbare if/else if keten.
• Init-instructie: switch x := f(); { ... }, bereik beperkt tot het blok.
• fallthrough bestaat maar is zeldzaam; gaat naar het volgende geval ZONDER de toestand ervan te evalueren.
• Type schakelaar v := i.(type) om onderscheid te maken op basis van het dynamische type (interfacemodule).