Switch idiomático

El switch de Go es más ergonómico que el de C/Java: cada case tiene la su bloque implícito (no hay break para escribir), se pueden agrupar múltiples valores con la coma, y un switch inexpresivo se comporta como una cadena if/else if más legible.

Cambiar a un valor

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

case acepta múltiples valores separados por comas y no hay ninguna solución alternativa implícito: tan pronto como se ejecuta un caso, el cambio sale.

Cambiar sin condición

Si omite la expresión, el modificador evalúa true y cada case es un condición bool. Es la alternativa idiomática a las cadenas largas 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")
}

Declaración de inicio

Al igual que con if, switch también acepta una declaración de inicio:

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

n existe solo dentro del conmutador.

fallthrough explícito

Si realmente desea que la ejecución caiga en el siguiente caso, debe escribirlo:

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

Tipo de cambio (noción)

Le permite discriminar según el tipo dinámico de un valor interfaz. Lo veremos en profundidad en el módulo de Interfaces:

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

Pruébalo tú mismo

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

Resumen

• case acepta múltiples valores separados por coma.
• Sin fallo implícito: cada caso tiene su propio break implícito.
• switch { ... } sin expresión = cadena if/else if más legible.
• Declaración de inicio: switch x := f(); { ... }, alcance limitado por bloques.
• fallthrough existe pero es poco común; entra en el caso posteriormente SIN evaluar su estado.
• Escriba el interruptor v := i.(type) para discriminar según el tipo dinámico (módulo de Interfaces).