Golang switch case: fallthrough und mehrere Werte

Ein switch vergleicht einen Wert mit einer Liste von Cases und führt den ersten Treffer aus. Anders als in C, Java und JavaScript fällt ein Go-Case nicht in den nächsten durch, es gibt also kein break, das du vergessen könntest.

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

Die Cases werden von oben nach unten geprüft, und nur der erste passende läuft. default läuft, wenn nichts passt; es ist optional und kann überall in der Liste stehen, per Konvention steht es aber am Ende.

Mehrere Werte pro Case

case "sat", "sun": passt auf beide Werte. So drückt Go aus, was C mit gestapelten leeren Cases macht. Jeder vergleichbare Typ funktioniert: Strings, Zahlen, Runes, Booleans, Pointer und benannte Typen wie 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))
	}
}

Zwei Cases mit demselben konstanten Wert sind ein Compilerfehler:

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

switch ohne Bedingung

Lässt du den Ausdruck weg, wird jeder Case zu einem booleschen Test. Das ist die sauberere Form einer langen if/else if-Kette in Go:

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 { ist die Kurzform für switch true {. Da der erste wahre Case gewinnt, zählt die Reihenfolge: bmi < 25 wird nur erreicht, wenn bmi < 18.5 falsch war, also kann jeder Case davon ausgehen, dass die darüber nicht gepasst haben.

switch mit Init-Anweisung

Wie if kann ein switch mit einer kurzen Anweisung beginnen. Dort deklarierte Variablen gelten nur im 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)
		}
	}
}

Die Init-Anweisung lässt sich auch mit einem switch ohne Ausdruck kombinieren: switch n := len(items); { case n == 0: ... }.

fallthrough

Willst du tatsächlich im nächsten Case weitermachen, schreib fallthrough als letzte Anweisung eines Case. Es übergibt die Kontrolle an den Rumpf des nächsten Case, ohne dessen Bedingung auszuwerten:

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

Level 2 gibt write und dann read aus und sammelt die Berechtigungen nach unten hin auf. Die Bedingungen der späteren Cases werden nicht geprüft: Nach fallthrough aus case 2 läuft case 1, obwohl level 2 ist.

Regeln für fallthrough:

• Es muss die letzte Anweisung im Case sein.
• Im letzten Case darf es nicht stehen: cannot fallthrough final case in switch.
• In einem Type Switch ist es nicht erlaubt.

In der Praxis ist fallthrough in Go-Code selten. Mehrere Werte pro Case decken den üblichen Bedarf, und explizite Funktionsaufrufe sind meist klarer als eine Kette von fallthroughs.

break in einem switch

break in einem Case verlässt den switch. Cases enden von selbst, also brauchst du es nur, um einen Case vorzeitig zu verlassen. Die Falle ist ein switch in einer Schleife:

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

Ohne das Label loop beendet break den switch, und die Schleife macht mit "c" weiter. continue dagegen bezieht sich immer auf die umschließende Schleife, da ein switch keine Schleife ist.

switch auf Typen

Ein Type Switch verzweigt nach dem dynamischen Typ eines Interface-Werts und nutzt dafür die spezielle Form 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))
}

In einem Case mit einem einzelnen Typ hat x diesen Typ (len(x) funktioniert im string-Case). In einem Case mit mehreren Typen behält x den Interface-Typ. Die Seite zu Type Assertions behandelt Type Switches und die Assertion v.(T) im Detail.

Was der switch von Go anders macht

Case-Ausdrücke müssen keine Konstanten sein. case limit(), max + 1: ist erlaubt; sie werden der Reihe nach ausgewertet, bis einer passt, also laufen spätere Ausdrücke unter Umständen nie.

Vollständigkeit

Go prüft nicht, ob ein switch über ein Enum jeden Wert abdeckt. Füg ein default hinzu, das bei unerwarteten Werten loggt, einen Fehler zurückgibt oder eine Panic auslöst, oder nutze den Linter exhaustive (Teil von golangci-lint), damit fehlende Cases beim Build gemeldet werden.