switch idiomatico

Lo switch di Go è più ergonomico di quello C/Java: ogni case ha il suo blocco implicito (niente break da scrivere), si possono raggruppare più valori con la virgola, e un switch senza espressione si comporta come una catena if/else if più leggibile.

Switch su un valore

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

I case accettano più valori separati da virgola e non c'è fallthrough implicito: appena un case è eseguito, lo switch esce.

Switch senza condizione

Se ometti l'espressione, lo switch valuta true e ogni case è una condizione bool. È l'alternativa idiomatica a lunghe catene 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")
}

Init statement

Come per if, anche switch accetta uno statement di init:

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

n esiste solo dentro lo switch.

fallthrough esplicito

Se vuoi davvero che l'esecuzione cada nel case successivo, devi scriverlo:

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 switch (cenno)

Permette di discriminare in base al tipo dinamico di un valore di interfaccia. Lo vedremo a fondo nel modulo Interfacce:

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

Prova tu

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

Recap

• case accettano valori multipli separati da virgola.
• Niente fallthrough implicito: ogni case ha il suo break implicito.
• switch { ... } senza espressione = catena if/else if più leggibile.
• Init statement: switch x := f(); { ... }, scope limitato al blocco.
• fallthrough esiste ma è raro; entra nel case dopo SENZA valutarne la condizione.
• Type switch v := i.(type) per discriminare in base al tipo dinamico (modulo Interfacce).