Go Wiki：Switch

规范：https://golang.ac.cn/ref/spec#Switch_statements

Go 的 switch 语句非常简洁。首先，您无需在每个 case 的末尾进行中断。

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 表示“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'")
}

贯穿

若要贯穿到后续 case，请使用 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

“fallthrough” 必须是 case 中的最后一条语句；您不能编写类似

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 不适用于类型转换。

多个 case

如果您想在同一个 case 中使用多个值，请使用逗号分隔列表。

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"

Noop case

有时，使用不需要任何操作的 case 会很有用。这看起来可能会令人困惑，因为它看起来 noop case 和后续 case 具有相同的作用，但事实并非如此。

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 的一部分。