switch case в Golang: fallthrough и несколько значений

switch сравнивает одно значение со списком вариантов и выполняет первое совпадение. В отличие от C, Java и JavaScript, ветка case в Go не проваливается в следующую, поэтому забыть break невозможно.

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

Варианты проверяются сверху вниз, и выполняется только первый совпавший. default выполняется, если ничего не совпало; он необязателен и может стоять в любом месте списка, но по соглашению его ставят последним.

Несколько значений в одном case

case "sat", "sun": совпадает с любым из значений. Так Go выражает то, что в C делают стопкой пустых case. Подходит любой сравнимый тип: строки, числа, руны, булевы значения, указатели и именованные типы, например перечисления:

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

Два case с одинаковым константным значением дают ошибку компиляции:

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

switch без условия

Уберите выражение, и каждый case превратится в булеву проверку. Это более чистая форма длинной цепочки 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 { это сокращение для switch true {. Побеждает первый истинный case, поэтому порядок важен: до bmi < 25 дело доходит, только если bmi < 18.5 оказалось ложным, так что каждый case может считать, что все варианты выше не сработали.

switch с инструкцией инициализации

Как и if, switch может начинаться с короткой инструкции. Объявленные в ней переменные видны только внутри 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)
		}
	}
}

Инструкцию инициализации можно сочетать и со switch без выражения: switch n := len(items); { case n == 0: ... }.

fallthrough

Если продолжить выполнение в следующем case всё же нужно, напишите fallthrough последней инструкцией ветки. Управление перейдёт в тело следующего case без вычисления его условия:

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

Уровень 2 печатает write, а затем read, накапливая права сверху вниз. Условия последующих case не проверяются: после fallthrough из case 2 выполняется case 1, хотя level равен 2.

Правила для fallthrough:

• Это должна быть последняя инструкция в ветке.
• Он не может стоять в последнем case: cannot fallthrough final case in switch.
• В type switch он запрещён.

На практике fallthrough в коде на Go встречается редко. Несколько значений в одном case покрывают обычную потребность, а явные вызовы функций обычно понятнее цепочки проваливаний.

break в switch

break внутри case выходит из switch. Ветки заканчиваются сами, поэтому он нужен, только чтобы покинуть ветку досрочно. Ловушка возникает, когда switch стоит внутри цикла:

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

Без метки loop оператор break завершит switch, а цикл продолжится до "c". А вот continue всегда относится к охватывающему циклу, ведь switch не является циклом.

switch по типам

Type switch выбирает ветку по динамическому типу значения интерфейса, используя особую форму 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))
}

В case с одним типом x имеет этот тип (в ветке string работает len(x)). В case с несколькими типами x остаётся интерфейсом. Type switch и утверждение v.(T) подробно разобраны на странице об утверждениях типа.

Чем switch в Go отличается

Выражения в case не обязаны быть константами. case limit(), max + 1: допустимо; они вычисляются по порядку до первого совпадения, поэтому более поздние выражения могут не выполниться вовсе.

Полнота вариантов

Go не проверяет, что switch по перечислению покрывает все значения. Добавьте default, который логирует, возвращает ошибку или паникует на неожиданных значениях, или используйте линтер exhaustive (входит в golangci-lint), чтобы пропущенные варианты сообщались при сборке.