Go Wiki：Switch

規格：https://go.dev.org.tw/ref/spec#Switch_statements

Go 的 switch 陳述式相當簡潔。首先，您不需要在每個情況的結尾中斷。

switch c {
case '&':
    esc = "&"
case '\'':
    esc = "'"
case '<':
    esc = "&lt;"
case '>':
    esc = "&gt;"
case '"':
    esc = "&quot;"
default:
    panic("unrecognized escape character")
}

src/pkg/html/escape.go

不只是整數

Switch 可用於任何類型的值。

switch syscall.OS {
case "windows":
    sd = &sysDir{
        Getenv("SystemRoot") + `\system32\drivers\etc`,
        []string{
            "hosts",
            "networks",
            "protocol",
            "services",
        },
    }
case "plan9":
    sd = &sysDir{
        "/lib/ndb",
        []string{
            "common",
            "local",
        },
    }
default:
    sd = &sysDir{
        "/etc",
        []string{
            "group",
            "hosts",
            "passwd",
        },
    }
}

缺少表達式

事實上，你根本不需要在任何東西上切換。沒有值的 switch 表示「切換 true」，這讓它成為 if-else 鏈的更簡潔版本，就像 Effective Go 中的這個範例

func unhex(c byte) byte {
    switch {
    case '0' <= c && c <= '9':
        return c - '0'
    case 'a' <= c && c <= 'f':
        return c - 'a' + 10
    case 'A' <= c && c <= 'F':
        return c - 'A' + 10
    }
    return 0
}

中斷

Go 的 switch 陳述式會隱含地 break，但 break 仍然有用

command := ReadCommand()
argv := strings.Fields(command)
switch argv[0] {
case "echo":
    fmt.Print(argv[1:]...)
case "cat":
    if len(argv) <= 1 {
        fmt.Println("Usage: cat <filename>")
        break
    }
    PrintFile(argv[1])
default:
    fmt.Println("Unknown command; try 'echo' or 'cat'")
}

貫穿

若要貫穿到後續案例，請使用 fallthrough 關鍵字

v := 42
switch v {
case 100:
    fmt.Println(100)
    fallthrough
case 42:
    fmt.Println(42)
    fallthrough
case 1:
    fmt.Println(1)
    fallthrough
default:
    fmt.Println("default")
}
// Output:
// 42
// 1
// default

另一個範例

// Unpack 4 bytes into uint32 to repack into base 85 5-byte.
var v uint32
switch len(src) {
default:
    v |= uint32(src[3])
    fallthrough
case 3:
    v |= uint32(src[2]) << 8
    fallthrough
case 2:
    v |= uint32(src[1]) << 16
    fallthrough
case 1:
    v |= uint32(src[0]) << 24
}

src/pkg/encoding/ascii85/ascii85.go

「貫穿」必須是案例中的最後一件事；你無法寫出類似這樣的東西

switch {
case f():
    if g() {
        fallthrough // Does not work!
    }
    h()
default:
    error()
}

不過，你可以使用「標籤」fallthrough來解決這個問題

switch {
case f():
    if g() {
        goto nextCase // Works now!
    }
    h()
    break
nextCase:
    fallthrough
default:
    error()
}

注意：fallthrough 不適用於類型切換。

多個案例

如果你想要在同一個案例中使用多個值，請使用以逗號分隔的清單。

func letterOp(code int) bool {
    switch chars[code].category {
    case "Lu", "Ll", "Lt", "Lm", "Lo":
        return true
    }
    return false
}

類型切換

使用類型切換，你可以切換介面值（僅限）的類型

func typeName(v interface{}) string {
    switch v.(type) {
    case int:
        return "int"
    case string:
        return "string"
    default:
        return "unknown"
    }
}

你也可以宣告一個變數，它將擁有每個 case 的類型

func do(v interface{}) string {
    switch u := v.(type) {
    case int:
        return strconv.Itoa(u*2) // u has type int
    case string:
        mid := len(u) / 2 // split - u has type string
        return u[mid:] + u[:mid] // join
    }
    return "unknown"
}

do(21) == "42"
do("bitrab") == "rabbit"
do(3.142) == "unknown"

空操作案例

有時候，擁有不需要動作的案例會很有用。這看起來可能會令人困惑，因為空操作案例和後續案例看起來好像有相同的動作，但事實並非如此。

func pluralEnding(n int) string {
    ending := ""

    switch n {
    case 1:
    default:
        ending = "s"
    }

    return ending
}

fmt.Sprintf("foo%s\n", pluralEnding(1))  == "foo"
fmt.Sprintf("bar%s\n", pluralEnding(2))  == "bars"

此內容是 Go Wiki 的一部分。