在 Golang 中，switch 语句是一种强大的多路分支控制结构，它允许你根据一个表达式的值来执行不同的代码块。switch 语句比使用一系列 if-else if 语句更清晰、更简洁。

以下是 Golang switch 语句的详细使用方法：

基本语法

go
switch expression {
case value1:
// 当 expression == value1 时执行的代码块
case value2:
// 当 expression == value2 时执行的代码块
case value3, value4: // 可以有多个值
// 当 expression == value3 或 expression == value4 时执行的代码块
default:
// 当 expression 不匹配任何 case 时执行的代码块 (可选)
}


关键组成部分：

1. switch expression:
* switch 关键字后面跟着一个表达式。这个表达式的类型可以是任何可比较的类型，例如整数、字符串、布尔值、结构体、枚举类型等。
* 注意: 在 Go 1.17 及以上版本，switch 表达式可以省略，这时它等价于 switch true。这使得 switch 可以在没有明确的表达式的情况下，仅依靠 case 后的布尔表达式进行判断。

2. case value:
* case 关键字后面跟着一个或多个常量值，这些值会被与 expression 进行比较。
* 如果 expression 的值与某个 case 的值匹配，那么该 case 块中的代码就会被执行。
* case 后的值必须是常量，并且类型必须与 expression 的类型兼容。
* 一个 case 后面可以列出多个值，用逗号分隔，表示只要匹配其中任何一个值，该 case 就会被触发。

3. default (可选):
* default 关键字后面跟着的代码块，会在 expression 的值不匹配任何 case 时执行。
* default 块是可选的，如果省略且没有匹配的 case，则 switch 语句什么也不做。
* 通常 default 块放在 switch 语句的最后，但它也可以放在前面。

4. 自动 break:
* 重要特性: 与许多其他语言（如 C、Java、JavaScript）不同，Golang 的 switch 语句在执行完匹配的 case 块后，会自动退出 switch 语句。你不需要显式地使用 break 关键字。
* fallthrough 关键字: 如果你确实需要执行下一个 case 块的代码（即使当前 case 匹配），可以使用 fallthrough 关键字。它必须是 case 块的最后一条语句。

示例

1. 基本用法 (字符串)

go
package main

import "fmt"

func main() {
day := "Monday"

switch day {
case "Monday":
fmt.Println("It's the start of the week.")
case "Friday":
fmt.Println("It's almost the weekend!")
case "Saturday", "Sunday": // 多个值
fmt.Println("It's the weekend!")
default:
fmt.Println("It's a weekday.")
}
}


2. 基本用法 (整数)

go
package main

import "fmt"

func main() {
score := 85

switch score {
case 90:
fmt.Println("Grade: A")
case 80:
fmt.Println("Grade: B")
case 70:
fmt.Println("Grade: C")
default:
fmt.Println("Grade: D or F")
}
}


3. 使用 fallthrough

go
package main

import "fmt"

func main() {
num := 2

switch num {
case 1:
fmt.Println("Case 1")
fallthrough // 执行下一个 case
case 2:
fmt.Println("Case 2")
fallthrough // 执行下一个 case
case 3:
fmt.Println("Case 3")
fallthrough
default:
fmt.Println("Default")
}
}


输出:

Case 2
Case 3
Default


4. 忽略 switch 表达式 (相当于 switch true)

go
package main

import "fmt"

func main() {
temperature := 30

switch { // 忽略表达式，等价于 switch true
case temperature > 35:
fmt.Println("It's very hot!")
case temperature > 30:
fmt.Println("It's hot.")
case temperature > 25:
fmt.Println("It's warm.")
default:
fmt.Println("It's moderate.")
}
}


这种写法非常有用，当你需要基于一系列复杂的布尔条件进行判断时，比 if-else if 链更加清晰。

5. switch 语句的初始化语句

与 for 循环类似，switch 语句也可以在 switch 关键字和表达式之间包含一个初始化语句。这个语句的作用域仅限于 switch 语句内部。

go
package main

import "fmt"

func main() {
switch val := getSomeValue(); val { // 初始化语句
case 1:
fmt.Println("Value is 1")
case 2:
fmt.Println("Value is 2")
default:
fmt.Println("Unknown value")
}
}

func getSomeValue() int {
return 1
}


6. switch 表达式作为变量的类型

switch 语句也可以用于类型断言。

go
package main

import "fmt"

func main() {
var i interface{} = "hello" // interface{} 可以存储任何类型

switch v := i.(type) { // 类型断言
case string:
fmt.Printf("This is a string: %v\n", v)
case int:
fmt.Printf("This is an int: %v\n", v)
case bool:
fmt.Printf("This is a bool: %v\n", v)
default:
fmt.Printf("Unknown type: %T\n", v)
}
}


总结 Golang switch 的特点：

* 自动 break: 减少了忘记 break 导致的 bug。
* fallthrough: 提供了一种灵活的控制流程，用于执行下一个 case。
* 忽略表达式: 允许 switch 基于一系列布尔表达式进行判断，简化 if-else if 链。
* 类型开关 (Type Switch): 使用 interface{} 类型结合 switch 可以方便地进行类型判断。
* 初始化语句: 可以在 switch 内部定义局部变量。
* case 支持多个值: 提高了代码的可读性和简洁性。

掌握 Golang 的 switch 语句可以让你编写出更清晰、更高效、更易于维护的代码。