基本用法

  • switch 关键字后面接条件表达式
  • case 从上到下按顺序进行匹配，直到匹配成功
  • 如果没有匹配到 case, 且有 default 模式， 会执行 default 的代码块
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func defaultSwitch() {
	switch time.Now().Weekday() {
	case time.Saturday:
		fmt.Println("Today is Saturday.")
	case time.Sunday:
		fmt.Println("Today is Sunday.")
	default:
		fmt.Println("Today is a weekday.")
	}
}

没有条件表达式

switch关键字后没有条件表达式， 默认认为是 true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func noConditionSwitch() {
	hour := time.Now().Hour()
	switch {
	case hour < 12:
		fmt.Println("Good morning!")
	case hour < 17:
		fmt.Println("Good afternoon!")
	default:
		fmt.Println("Good evening!")
	}
}

Or 匹配

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func orSwitch() {
	c := '\t'
	var iswhiteSpace bool
	switch c {
	case ' ', '\t', '\n', '\f', '\r':
		iswhiteSpace = true
	}
	if iswhiteSpace {
		fmt.Println("c is a white_space char")
	}

}

Fallthrough

  • fallthrough 语句会跳到下一个 case
  • 只能放在 case代码块的最后位置
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func fallthroughSwitch() {
	switch 2 {
	case 1:
		fmt.Println("1")
		fallthrough
	case 2:
		fmt.Println("2")
		fallthrough
	case 3:
		fmt.Println("3")
	}
}

通过 break 退出 switch

  • break 语句终止 switch 继续执行
  • 如果要跳出外层的 for 循环，而不是 switch，可以在循环上加一个标签，然后 break 到这个标签
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func breakSwitch() {
Loop:
	for _, ch := range "a b\nc" {
		switch ch {
		case ' ': // skip space
			break
		case '\n': // break at newline
			break Loop
		default:
			fmt.Printf("%c\n", ch)
		}
	}
}

执行顺序

  • switch 表达式一开始会被执行
  • 之后 case 表达式从左到右、从上到下匹配：
    1. 第一个相等的 case, 会触发匹配到的代码块的执行
    2. 其他 case 会被忽略
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

func executeOrder() {
	// Foo prints and returns n.
	var Foo func(int) int
	Foo = func(n int) int {
		fmt.Println(n)
		return n
	}

	switch Foo(2) {
	case Foo(1), Foo(2), Foo(3):
		fmt.Println("First case")
		fallthrough
	case Foo(4):
		fmt.Println("Second case")
	}
}