Go言語のswitch文：fallthroughと複数の値

switch は1つの値をcaseのリストと比べ、最初に一致したものを実行します。C、Java、JavaScriptと違って、Goのcaseは次のcaseに フォールスルーしない ので、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))
	}
}

caseは上から下へチェックされ、最初に一致したcaseだけが実行されます。default は何も一致しないときに実行されます。省略でき、リストのどこに置いても構いませんが、慣習では最後に置きます。

caseごとの複数の値

case "sat", "sun": はどちらの値にも一致します。Cが空のcaseを積み重ねて表すことを、Goはこう書きます。比較可能な型なら何でも使えます。文字列、数値、ルーン、真偽値、ポインタ、そして列挙型のような名前付きの型です。

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

同じ定数値を持つ2つの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 の連鎖を、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 { は switch true { の省略形です。最初に真になったcaseが勝つので、順序が重要です。bmi < 25 に到達するのは bmi < 18.5 が偽だったときだけなので、各caseは上の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に実行を続けたいときは、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の条件はチェックされません。case 2 から fallthrough した後は、level が2であっても case 1 が実行されます。

fallthrough のルールは次のとおりです。

• caseの最後の文でなければならない。
• 最後のcaseには書けない：cannot fallthrough final case in switch。
• 型スイッチでは使えない。

実際のGoのコードで fallthrough を見ることはまれです。caseごとの複数の値でよくある用途はまかなえますし、fallthroughの連鎖より明示的な関数呼び出しのほうがたいてい明快です。

switchの中のbreak

case内の break は switch を抜けます。caseは自然に終わるので、必要になるのはcaseを途中で抜けるときだけです。罠になるのは、ループの中の 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

型スイッチは、特別な形 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))
}

型が1つだけのcaseでは、x はその型になります（string のcaseでは len(x) が使えます）。複数の型を並べたcaseでは、x はインターフェース型のままです。型スイッチと v.(T) のアサーションは型アサーションのページで詳しく扱っています。

Goのswitchが違うところ

caseの式は定数である必要はありません。case limit(), max + 1: も正しいコードです。一致するまで順に評価されるので、後ろの式は一度も実行されないこともあります。

網羅性

Goは、列挙型に対するswitchがすべての値を網羅しているかをチェックしません。想定外の値に対してログを出す、エラーを返す、またはpanicする default を加えるか、exhaustive リンター（golangci-lint の一部）を使って、漏れたcaseをビルド時に報告させます。