Switch case w Golang: fallthrough i wiele wartości

switch porównuje jedną wartość z listą przypadków i wykonuje pierwszy pasujący. Inaczej niż w C, Javie i JavaScripcie przypadek w Go nie przechodzi do następnego, więc nie ma break, o którym można zapomnieć.

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

Przypadki są sprawdzane od góry do dołu i wykonuje się tylko pierwszy pasujący. default wykonuje się, gdy nic nie pasuje; jest opcjonalny i może stać w dowolnym miejscu listy, choć zgodnie z konwencją jest na końcu.

Wiele wartości w jednym przypadku

case "sat", "sun": pasuje do każdej z tych wartości. W ten sposób Go wyraża to, co C robi przez ułożone jeden pod drugim puste przypadki. Działa każdy porównywalny typ: stringi, liczby, rune, wartości logiczne, wskaźniki i typy nazwane, takie jak enumy:

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

Dwa przypadki z tą samą stałą wartością to błąd kompilacji:

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

Switch bez warunku

Pomiń wyrażenie, a każdy przypadek stanie się testem logicznym. To czytelniejsza w Go forma długiego łańcucha 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 { to skrót od switch true {. Ponieważ wygrywa pierwszy prawdziwy przypadek, kolejność ma znaczenie: do bmi < 25 dochodzi się tylko wtedy, gdy bmi < 18.5 było fałszywe, więc każdy przypadek może zakładać, że te powyżej nie zadziałały.

Switch z instrukcją inicjalizującą

Podobnie jak if, switch może zaczynać się od krótkiej instrukcji. Zadeklarowane w niej zmienne mają zasięg ograniczony 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)
		}
	}
}

Instrukcję inicjalizującą można też połączyć ze switch bez wyrażenia: switch n := len(items); { case n == 0: ... }.

fallthrough

Gdy naprawdę chcesz przejść do następnego przypadku, napisz fallthrough jako ostatnią instrukcję przypadku. Przekazuje ono sterowanie do ciała następnego przypadku bez obliczania jego warunku:

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

Poziom 2 wypisuje write, a potem read, kumulując uprawnienia w dół. Warunki późniejszych przypadków nie są sprawdzane: po fallthrough z case 2 wykonuje się case 1, mimo że level wynosi 2.

Zasady dla fallthrough:

• Musi być ostatnią instrukcją w przypadku.
• Nie może wystąpić w ostatnim przypadku: cannot fallthrough final case in switch.
• Nie jest dozwolone w type switch.

W praktyce fallthrough rzadko występuje w kodzie Go. Wiele wartości w jednym przypadku pokrywa typową potrzebę, a jawne wywołania funkcji są zwykle czytelniejsze niż łańcuch fallthrough.

break w switch

break wewnątrz przypadku wychodzi ze switch. Przypadki kończą się same, więc potrzebujesz go tylko do wcześniejszego opuszczenia przypadku. Pułapką jest switch wewnątrz pętli:

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

Bez etykiety loop instrukcja break kończy switch, a pętla idzie dalej do "c". Za to continue zawsze odnosi się do otaczającej pętli, bo switch nie jest pętlą.

Switch po typach

Type switch rozgałęzia się według dynamicznego typu wartości interfejsu, używając specjalnej formy 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))
}

W przypadku z jednym typem x ma ten typ (len(x) działa w przypadku string). W przypadku z kilkoma typami x zachowuje typ interfejsu. Strona o asercjach typów szczegółowo omawia type switch i asercję v.(T).

Czym switch w Go różni się od innych

Wyrażenia w przypadkach nie muszą być stałymi. case limit(), max + 1: jest poprawne; są obliczane po kolei, aż któreś pasuje, więc późniejsze wyrażenia mogą się nigdy nie wykonać.

Wyczerpujące pokrycie

Go nie sprawdza, czy switch po enumie obejmuje każdą wartość. Dodaj default, który loguje, zwraca błąd lub wywołuje panic dla nieoczekiwanych wartości, albo użyj lintera exhaustive (część golangci-lint), żeby brakujące przypadki były zgłaszane podczas budowania.