什么是 switch 语句?


switch 是一个条件语句，它计算表达式并将其与可能匹配的列表进行比较，然后根据匹配执行代码块。它可以被认为是书写多个 if else 语句的替代方法。**

Example

让我们从一个简单的例子开始，该例子将手指数作为输入并输出该手指的名称:)。例如1 是拇指，2 是食指，依此类推。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     finger := 4
  9.     switch finger {
  10.     case 1:
  11.         fmt.Println("Thumb")
  12.     case 2:
  13.         fmt.Println("Index")
  14.     case 3:
  15.         fmt.Println("Middle")
  16.     case 4:
  17.         fmt.Println("Ring")
  18.     case 5:
  19.         fmt.Println("Pinky")
  20.     }
  21. }

Run in playground

在上述程序中，switch finger 将 finger 的值与每个 case 语句进行比较。cases 从上到下进行比较，并执行与表达式匹配的第一个 case 。在这种 case 下，finger 的值为 4，因此程序得到打印

  1. Finger 4 is Ring


cases 不允许出现重复

不允许使用相同常数值的重复 case。如果你试图运行下面的程序，编译器会报错 ./prog.go:19:7: duplicate case 4 in switch previous case at ./prog.go:17:7

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     finger := 4
  9.     fmt.Printf("Finger %d is ", finger)
  10.     switch finger {
  11.     case 1:
  12.         fmt.Println("Thumb")
  13.     case 2:
  14.         fmt.Println("Index")
  15.     case 3:
  16.         fmt.Println("Middle")
  17.     case 4:
  18.         fmt.Println("Ring")
  19.     case 4: //duplicate case
  20.         fmt.Println("Another Ring")
  21.     case 5:
  22.         fmt.Println("Pinky")
  24.     }
  25. }

Run in playground

default case

我们手中只有 5 个手指。如果输入错误的手指数会发生什么。这是 default case 。当其他 case 都不匹配时，将执行 default case。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     switch finger := 8; finger {
  9.     case 1:
  10.         fmt.Println("Thumb")
  11.     case 2:
  12.         fmt.Println("Index")
  13.     case 3:
  14.         fmt.Println("Middle")
  15.     case 4:
  16.         fmt.Println("Ring")
  17.     case 5:
  18.         fmt.Println("Pinky")
  19.     default: //default case
  20.         fmt.Println("incorrect finger number")
  21.     }
  22. }

Run in playground

在上面的程序中，finger 是 8 并且它与任何 case 都不匹配，因此输出 incorrect finger number。没有必要将 default 放在 switch 语句中的最后。它可以出现在 swich语句中的任何地方。

你可能还注意到了 finger 声明中的一个小变化。它在 switch 中声明。switch 可以包含一个可选语句，该语句在计算表达式之前执行。在这一行中 switch finger := 8; finger 首先被声明，也用于表达式中。在这种 case 下，finger 的范围仅限于 switch 代码块里。

多个表达式在 case 中

通过用逗号分隔多个表达式，可以在一个 case 中包含它们。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     letter := "i"
  9.     fmt.Printf("Letter %s is a ", letter)
  10.     switch letter {
  11.     case "a", "e", "i", "o", "u": //multiple expressions in case
  12.         fmt.Println("vowel")
  13.     default:
  14.         fmt.Println("not a vowel")
  15.     }
  16. }

Run in playground

上面的程序可以发现 letter 是否是元音。第 11 行代码 case “a”, “e”, “i”, “o”, “u”: 匹配所有元音。因为 i 是元音，所以这个程序得到打印

  1. Letter i is a vowel

省略的 switch 表达式

switch 中的表达式是可选的，可以省略。如果省略表达式，则认为 switch true，并对每个case 表达式求真值，并执行相应的代码块。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     num := 75
  9.     switch { // expression is omitted
  10.     case num >= 0 && num <= 50:
  11.         fmt.Println("num is greater than 0 and less than 50")
  12.     case num >= 51 && num <= 100:
  13.         fmt.Println("num is greater than 51 and less than 100")
  14.     case num >= 101:
  15.         fmt.Println("num is greater than 100")
  16.     }
  17. }

Run in playground

在上面的程序中，switch中没有该表达式，因此它被认为是 true，并对每种 case 求值。第 12 行代码 case num >= 51 && num <= 100: 语句为真，程序得到打印

  1. 75 is greater than 51 and less than 100

这种类型的 switch 可以作为多个 if else 语句的替代写法。

Fallthrough

在 Go 中，执行 case 后，control 立即从 switch 语句中出来。fallthrough 语句用于将控制权转移到紧随已执行的 case 之后出现的 case 的第一条语句。

让我们写一个程序来理解 fallthrough。我们的程序会检查输入的数字是否小于 50、100 或 200。例如，如果我们输入 75，程序将打印 75 小于 100 和 200。我们将使用 fallthrough 来实现。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func number() int {  
  8.         num := 15 * 5 
  9.         return num
  10. }
  12. func main() {
  14.     switch num := number(); { //num is not a constant
  15.     case num < 50:
  16.         fmt.Printf("%d is lesser than 50\n", num)
  17.         fallthrough
  18.     case num < 100:
  19.         fmt.Printf("%d is lesser than 100\n", num)
  20.         fallthrough
  21.     case num < 200:
  22.         fmt.Printf("%d is lesser than 200", num)
  23.     }
  25. }

Run in playground

Switch 和 case 表达式不一定只是常量。它们也可以在运行时进行判断。在上面的程序中，第 14 行 num 初始化为函数 number() 的返回值。control 位于 switch 内部，并对 case 进行判断。第 18 行 case num < 100: 为真，程序输出 75 is lesser than 100。下一个语句是 fallthrough。当遇到 fallthrough 时，control 将移动到下一个 case 的第一个语句，并输出 75 is lesser than 200。程序的输出为

  1. 75 is lesser than 100  
  2. 75 is lesser than 200

fallthrough 应该在 case 语句中最后声明， 如果它出现在中间的某个地方，编译器将抛出错误 fallthrough statement out of place。

即使 case 计算为 false，也会发生 Fallthrough 现象

在使用 fallthrough 时，有一个微妙的地方需要考虑。即使 case 被计算为 false，也会发生 fallthrough。

请思考以下程序

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     switch num := 25; { 
  9.     case num < 50:
  10.         fmt.Printf("%d is lesser than 50\n", num)
  11.         fallthrough
  12.     case num > 100:
  13.         fmt.Printf("%d is greater than 100\n", num)     
  14.     }
  16. }

Run in playground

在上面的程序中，num 为 25，小于 50，因此第 9 行的 case 计算为真。在第 11 行出现了一个 fallthrough。在第 12 行中 case num > 100: ，由于 num < 100，所以为假。但是 fallthrough 没有考虑到这一点。即使 case 的值为 false，也会发生 fallthrough。

上面的程序将打印

  1. 25 is lesser than 50  
  2. 25 is greater than 100



因此，请确保你了解使用 fallthrough 时的操作。

还有一件事是，在没有 switch 的 case 下，不能在 switch 的最后一种 case 下使用 fallthrough。 如果在最后一种 case 下存在 fallthrough，则将导致以下编译错误。

  1. cannot fallthrough final case in switch

退出 switch

break 语句可用于在 switch 完成之前提早终止 switch。 让我们将上面的示例修改为一个人为的示例，以了解 break 的工作原理。

让我们添加一个条件，如果 num 小于0，则 switch 应终止。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     switch num := -5; {
  9.     case num < 50:
  10.         if num < 0 {
  11.             break
  12.         }
  13.         fmt.Printf("%d is lesser than 50\n", num)
  14.         fallthrough
  15.     case num < 100:
  16.         fmt.Printf("%d is lesser than 100\n", num)
  17.         fallthrough
  18.     case num < 200:
  19.         fmt.Printf("%d is lesser than 200", num)
  20.     }
  22. }

Run in playground

在上面的程序中，num 为 -5，当 control 到达第 10 行的 if 语句时，由于 num < 0，所以条件满足。在程序完成之前，break 语句终止了 switch，程序没有打印任何内容:)。

退出外部 for 循环

当 switch case 在 for 循环内部时，可能需要提前终止 for 循环。这可以通过给 for 循环打上标签，并在 switch 语句内使用该标签退出 for 循环来实现。我们来看一个例子。

让我们写一个程序来生成一个随机的偶数。

我们将创建一个无限的 for 循环，并使用 switch 情况来确定生成的随机数是否是偶数。如果是偶数，则打印生成的数字，并使用其标签终止 for 循环。rand 包的 Intn 函数用于生成非负的伪随机数。

  1. package main
  3. import (  
  4.     "fmt"
  5.     "math/rand"
  6. )
  8. func main() {  
  9. randloop:  
  10.     for {
  11.         switch i := rand.Intn(100); {
  12.         case i%2 == 0:
  13.             fmt.Printf("Generated even number %d", i)
  14.             break randloop
  15.         }
  16.     }
  18. }

Run in playground

在上面的程序中，第 9 行 for 循环标签为 randloop。第 11 行使用的 Intn 函数，在 0 到 99 之间生成一个随机数(不包括 100)。如果生成的数字是偶数，则在第 14 行使用标签退出循环。

这个程序打印。


  1. Generated even number 18

请注意，如果使用 break 语句而不使用标签，switch 语句只会被退出，循环会继续运行。所以给循环打上标签，并在 switch 里面的 break 语句中使用，是退出外层 for 循环的必要条件。

本教程到此结束。还有一种类型的 switch 叫做 type switch。我们在学习 interfaces 的时候会研究这个问题。

**

原文链接

https://golangbot.com/switch/