switch case em Golang: fallthrough e vários valores por case

Um switch compara um valor com uma lista de cases e executa o primeiro que casar. Diferente de C, Java e JavaScript, um case em Go não cai no próximo (não há fall through), então não existe break para esquecer.

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

Os cases são verificados de cima para baixo, e só o primeiro que casar é executado. default executa quando nada casa; ele é opcional e pode aparecer em qualquer posição da lista, embora por convenção fique por último.

Vários valores por case

case "sat", "sun": casa com qualquer um dos dois valores. É assim que Go expressa o que C faz com cases vazios empilhados. Qualquer tipo comparável funciona: strings, números, runes, booleanos, ponteiros e tipos nomeados como 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))
	}
}

Dois cases com o mesmo valor constante são erro de compilação:

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

switch sem condição

Deixe a expressão de fora e cada case vira um teste booleano. Essa é a forma mais limpa que Go tem de escrever uma cadeia longa 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 { é um atalho para switch true {. Como o primeiro case verdadeiro vence, a ordem importa: bmi < 25 só é alcançado quando bmi < 18.5 foi falso, então cada case pode assumir que os de cima falharam.

switch com instrução de inicialização

Como o if, um switch pode começar com uma instrução curta. As variáveis declaradas ali têm o escopo do 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)
		}
	}
}

A instrução de inicialização também pode ser combinada com um switch sem expressão: switch n := len(items); { case n == 0: ... }.

fallthrough

Quando você quer mesmo continuar no próximo case, escreva fallthrough como última instrução de um case. Ele passa o controle para o corpo do próximo case sem avaliar a condição dele:

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

O nível 2 imprime write e depois read, acumulando permissões para baixo. As condições dos cases seguintes não são verificadas: depois do fallthrough a partir do case 2, o case 1 executa mesmo com level valendo 2.

Regras do fallthrough:

• Precisa ser a última instrução do case.
• Não pode aparecer no último case: cannot fallthrough final case in switch.
• Não é permitido em um type switch.

Na prática, fallthrough é raro em código Go. Vários valores por case resolvem a necessidade comum, e chamadas explícitas de função costumam ser mais claras que uma cadeia de fallthroughs.

break em um switch

break dentro de um case sai do switch. Os cases terminam sozinhos, então você só precisa dele para sair mais cedo de um case. A armadilha é um switch dentro de um laço:

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

Sem o label loop, o break encerra o switch e o laço segue para "c". Já o continue sempre se refere ao laço que envolve o switch, já que um switch não é um laço.

switch sobre tipos

Um type switch ramifica pelo tipo dinâmico de um valor de interface, usando a 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))
}

Em um case com um único tipo, x tem esse tipo (len(x) funciona no case string). Em um case que lista vários tipos, x mantém o tipo da interface. A página de type assertions cobre type switches e a assertion v.(T) em detalhes.

O que o switch do Go faz diferente

As expressões dos cases não precisam ser constantes. case limit(), max + 1: é válido; elas são avaliadas em ordem até uma casar, então as expressões seguintes podem nunca ser executadas.

Exaustividade

Go não verifica se um switch sobre um enum cobre todos os valores. Acrescente um default que registra em log, devolve um erro ou causa panic para valores que você não esperava, ou use o linter exhaustive (parte do golangci-lint) para que cases faltando sejam reportados no build.