switch case en Golang: fallthrough y varios valores

Un switch compara un valor con una lista de casos y ejecuta el primero que coincide. A diferencia de C, Java y JavaScript, un caso de Go no cae al siguiente, así que no hay ningún break que olvidar.

package main

import "fmt"

func describe(day string) string {
	switch day {
	case "sat", "sun":
		return "weekend"
	case "fri":
		return "almost weekend"
	case "mon", "tue", "wed", "thu":
		return "weekday"
	default:
		return "not a day"
	}
}

func main() {
	for _, d := range []string{"sun", "fri", "tue", "xyz"} {
		fmt.Println(d, "->", describe(d))
	}
}

Los casos se comprueban de arriba abajo, y solo se ejecuta el primero que coincide. default se ejecuta cuando nada coincide; es opcional y puede ir en cualquier posición de la lista, aunque por convención va el último.

Varios valores por caso

case "sat", "sun": coincide con cualquiera de los dos valores. Así expresa Go lo que C hace con casos vacíos apilados. Sirve cualquier tipo comparable: strings, números, runes, booleanos, punteros y tipos con nombre como los enums:

package main

import "fmt"

func kind(r rune) string {
	switch r {
	case 'a', 'e', 'i', 'o', 'u':
		return "vowel"
	case ' ', '\t', '\n':
		return "space"
	default:
		return "other"
	}
}

func main() {
	for _, r := range "go on" {
		fmt.Printf("%q %s\n", r, kind(r))
	}
}

Dos casos con el mismo valor constante son un error de compilación:

./main.go:10:7: duplicate case 1 (constant of type int) in expression switch
	./main.go:8:7: previous case

switch sin condición

Si omites la expresión, cada caso se convierte en una comprobación booleana. Es la forma más limpia que tiene Go de escribir una cadena larga de if/else if:

package main

import "fmt"

func bmiCategory(bmi float64) string {
	switch {
	case bmi < 18.5:
		return "underweight"
	case bmi < 25:
		return "normal"
	case bmi < 30:
		return "overweight"
	default:
		return "obese"
	}
}

func main() {
	for _, b := range []float64{17.2, 22.0, 27.9, 31.5} {
		fmt.Printf("%.1f %s\n", b, bmiCategory(b))
	}
}

switch { es una abreviatura de switch true {. Como gana el primer caso verdadero, el orden importa: a bmi < 25 solo se llega cuando bmi < 18.5 era falso, así que cada caso puede dar por hecho que fallaron los de arriba.

switch con sentencia de inicio

Igual que if, un switch puede empezar con una sentencia corta. Las variables declaradas en ella quedan limitadas al switch:

package main

import (
	"fmt"
	"strings"
)

func main() {
	inputs := []string{"  YES ", "no", "maybe"}

	for _, in := range inputs {
		switch answer := strings.ToLower(strings.TrimSpace(in)); answer {
		case "y", "yes":
			fmt.Println("confirmed")
		case "n", "no":
			fmt.Println("declined")
		default:
			fmt.Printf("unknown answer %q\n", answer)
		}
	}
}

La sentencia de inicio también se puede combinar con un switch sin condición: switch n := len(items); { case n == 0: ... }.

fallthrough

Cuando sí quieres continuar en el siguiente caso, escribe fallthrough como última sentencia de un caso. Pasa el control al cuerpo del siguiente caso sin evaluar su condición:

package main

import "fmt"

func main() {
	level := 2

	fmt.Println("permissions for level", level)
	switch level {
	case 3:
		fmt.Println("  delete")
		fallthrough
	case 2:
		fmt.Println("  write")
		fallthrough
	case 1:
		fmt.Println("  read")
	}
}

El nivel 2 imprime write y luego read, acumulando permisos hacia abajo. Las condiciones de los casos posteriores no se comprueban: tras el fallthrough desde case 2, case 1 se ejecuta aunque level valga 2.

Reglas de fallthrough:

• Tiene que ser la última sentencia del caso.
• No puede aparecer en el último caso: cannot fallthrough final case in switch.
• No está permitido en un type switch.

En la práctica, fallthrough es raro en el código Go. Los varios valores por caso cubren la necesidad habitual, y las llamadas explícitas a funciones suelen ser más claras que una cadena de fallthroughs.

break en un switch

break dentro de un caso sale del switch. Los casos terminan solos, así que solo lo necesitas para salir antes de un caso. La trampa es un switch dentro de un bucle:

package main

import "fmt"

func main() {
	commands := []string{"a", "b", "quit", "c"}

loop:
	for _, cmd := range commands {
		switch cmd {
		case "quit":
			fmt.Println("quitting")
			break loop // a plain break would only leave the switch
		default:
			fmt.Println("run", cmd)
		}
	}
}

Sin la etiqueta loop, break termina el switch y el bucle sigue hasta "c". continue, en cambio, siempre se refiere al bucle que lo contiene, porque un switch no es un bucle.

switch sobre tipos

Un type switch se ramifica según el tipo dinámico de un valor de interfaz, usando la forma especial v.(type):

package main

import "fmt"

func describe(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil"
	case int, int64:
		return fmt.Sprintf("integer %v", x)
	case string:
		return fmt.Sprintf("string of length %d", len(x))
	case error:
		return "error: " + x.Error()
	default:
		return fmt.Sprintf("something else: %T", x)
	}
}

func main() {
	fmt.Println(describe(42))
	fmt.Println(describe("hello"))
	fmt.Println(describe(fmt.Errorf("boom")))
	fmt.Println(describe(3.14))
	fmt.Println(describe(nil))
}

En un caso con un solo tipo, x tiene ese tipo (len(x) funciona en el caso string). En un caso que enumera varios tipos, x conserva el tipo de la interfaz. La página de aserciones de tipo trata en detalle los type switches y la aserción v.(T).

Lo que el switch de Go hace distinto

Las expresiones de los casos no tienen por qué ser constantes. case limit(), max + 1: es válido; se evalúan en orden hasta que una coincide, así que las expresiones posteriores pueden no ejecutarse nunca.

Exhaustividad

Go no comprueba que un switch sobre un enum cubra todos los valores. Añade un default que registre, devuelva un error o provoque un panic ante valores que no esperabas, o usa el linter exhaustive (parte de golangci-lint) para que los casos que faltan se informen al compilar.