Golang switch case: fallthrough and Multiple Values

A switch compares one value against a list of cases and runs the first match. Unlike C, Java and JavaScript, a Go case does not fall through to the next one, so there is no break to forget.

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

Cases are checked from top to bottom, and only the first matching case runs. default runs when nothing matches; it is optional and can appear anywhere in the list, though it goes last by convention.

Multiple Values per Case

case "sat", "sun": matches either value. This is how Go expresses what C does with stacked empty cases. Any comparable type works: strings, numbers, runes, booleans, pointers, and named types such as 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))
	}
}

Two cases with the same constant value are a compile error:

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

Switch with No Condition

Leave out the expression and each case becomes a boolean test. This is Go's cleaner form of a long if/else if chain:

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 { is shorthand for switch true {. Because the first true case wins, order matters: bmi < 25 is only reached when bmi < 18.5 was false, so each case can assume the ones above failed.

Switch with an Init Statement

Like if, a switch can start with a short statement. Variables declared there are scoped to the 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)
		}
	}
}

The init statement can also be combined with a tagless switch: switch n := len(items); { case n == 0: ... }.

fallthrough

When you do want to continue into the next case, write fallthrough as the last statement of a case. It transfers control to the next case's body without evaluating its condition:

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 prints write and then read, accumulating permissions downward. The conditions of the later cases are not checked: after fallthrough from case 2, case 1 runs even though level is 2.

Rules for fallthrough:

• It must be the last statement in the case.
• It cannot appear in the final case: cannot fallthrough final case in switch.
• It is not allowed in a type switch.

In practice fallthrough is rare in Go code. Multiple values per case cover the common need, and explicit function calls are usually clearer than a chain of fallthroughs.

break in a switch

break inside a case exits the switch. Cases end on their own, so you only need it to leave a case early. The trap is a switch inside a loop:

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

Without the loop label, break ends the switch and the loop carries on to "c". continue, on the other hand, always refers to the enclosing loop, since a switch is not a loop.

Switch on Types

A type switch branches on the dynamic type of an interface value, using the special 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 a case with a single type, x has that type (len(x) works in the string case). In a case listing several types, x keeps the interface type. The type assertions page covers type switches and the v.(T) assertion in detail.

Things Go's switch Does Differently

Case expressions do not have to be constants. case limit(), max + 1: is legal; they are evaluated in order until one matches, so later expressions may never run.

Exhaustiveness

Go does not check that a switch over an enum covers every value. Add a default that logs, returns an error or panics for values you did not expect, or use the exhaustive linter (part of golangci-lint) to have missing cases reported at build time.