5. golang之switch分支控制

1. 基本的介绍

1）switch 语句用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上到下逐一测试，直到匹配为止。

2）匹配项后面不需要再加aibreak

2. 基本语法

 3. switch的流程图

 对上图的说明和总结

1）switch的执行流程是，先执行表达式，得到值，然后和case的表达式进行比较，如果相等，就匹配到，然后执行对应的case的语句块，然后退出switch控制。

2）如果switch的表达式的值没有和任何的case的表达式匹配成功，则执行default的语句块。执行后退出switch的控制。

3）golang的case后的表达式可以有多个，使用逗号间隔

4）golang中的case语句块不需要写break，因为默认会有，即在默认情况下，当程序执行完case语句块后，就直接退出该switch控制结构。

4.switch快速入门案例

案例：

请编写一个程序，该程序可以接收一个字符，比如：a，b，c，d，e，f，g。a表示星期一，b表示星期二，根据用户的输入显示相应的信息。要求使用switch语句完成。

package main
import (
	"fmt"
)
func main() {
	var key byte
	fmt.Println("请输入一个字符：a、b、c、d、e、f、g")
	fmt.Scanf("%c",&key)
	switch key {
		case 'a':
			fmt.Println("周一，猴子穿新衣服")
		case 'b':
			fmt.Println("周二")
		case 'c':
			fmt.Println("周三")
		case 'd':
			fmt.Println("周四")
		case 'e':
			fmt.Println("周五")
		case 'f':
			fmt.Println("周六")
		case 'g':
			fmt.Println("周日")
		default:
			fmt.Println("输入有误")
	}
}

5. swtich的使用的注意事项和细节

1）case/switch后是一个表达式（即：常量值、变量、一个有返回值的函数等都可以）

package main
import (
	"fmt"
)

func test(char byte)byte {
	return char + 1
}

func main() {
	var key byte
	fmt.Println("请输入一个字符：a、b、c、d、e、f、g")
	fmt.Scanf("%c",&key)
	switch test(key)+1 { //将语法现象
		case 'a':
			fmt.Println("周一，猴子穿新衣服")
		case 'b':
			fmt.Println("周二")
		case 'c':
			fmt.Println("周三")
		case 'd':
			fmt.Println("周四")
		case 'e':
			fmt.Println("周五")
		case 'f':
			fmt.Println("周六")
		case 'g':
			fmt.Println("周日")
		default:
			fmt.Println("输入有误")
	}
}

2）case后的各个表达式的数据类型，必须和switch的表达式数据类型一致

// 2.case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致
	var n1 int32 = 20
	var n2 int64 = 20
	switch n1 {
	case n2: // 错误，原因是n2的数据类型和n1不一致，如过这里改成20则可以，因为这时并不是一个具体的数据类型
		 fmt.Println("ok1")
	default:
		fmt.Println("没有匹配到")
	}

3）case后面可以带多个表达式，使用逗号间隔。比如case表达式1，表达式2...

// 3. case后面可以带多个表达式，使用逗号间隔。比如case表达式1，表达式2...
	var n3 int32 = 5
	var n4 int32 = 20
	switch n3 {
	case n4,10,5:
		fmt.Println("ok1")
	default:
		fmt.Println("没有匹配到")
	}

4）case后面的表达式如果是常量值（字面量），则要求不能重复

// 4. case后面的表达式如果是常量值（字面量），则要求不能重复
	var n5 int32 = 5
	var n6 int32 = 20
	var n7 int32 = 5
	switch n5 {
	case n6,10,5:
		fmt.Println("ok1")
	case n7:	// 如果是个变量值和已有的重复，则检测不出来会通过
		fmt.Println("ok2")
	case 5:	// 错误，因为前面我们有常量5，因此重复，就会报错
		fmt.Println("ok3")
	}

5）case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default

6）default语句不是必须的

7）switch后也可以不带表达式，类似if--else分支来使用。

package main
import (
	"fmt"
)
func main() {
	// 7. switch后面也可以不带表达式，类似 if-- else分支来使用。【案例演示】
	var age int = 10
	switch {
	case age == 10:
		fmt.Println("age == 10")
	case age == 20:
		fmt.Println("age == 20")
	default:
		fmt.Println("没有匹配到")
	}
	// 7. case 中可以对范围进行判断
	var score int = 90
	switch {
	case score > 90:
		fmt.Println("成绩优秀")
	case score >= 70 && score <= 90:
		fmt.Println("成绩优良")
	case score >= 60 && score < 70:
		fmt.Println("成绩及格")
	default:
		fmt.Println("成绩不及格")		
	}
}

8）switch后也可以直接声明/定义一个变量，分号结束，不推荐

package main
import (
	"fmt"
)
func main() {
	// 8. switch后面也可以直接声明一个变量，分号结束，不推荐
	switch grade := 90; { // 在golang中也可以这么写，不能忘了分号
	case grade > 90:
		fmt.Println("成绩优秀")
	case grade >= 70 && grade <= 90:
		fmt.Println("成绩优良")
	case grade >= 60 && grade < 70:
		fmt.Println("成绩及格")
	case grade < 60:
		fmt.Println("成绩不及格")
	}
}

9）switch 穿透-fallthrough，如果在case语句块后增加fallthrough，则会继续执行下一个case，也叫switch穿透：建议穿透不要过多使用

package main
import (
	"fmt"
)
func main() {
	// 9. switch穿透：fallthrough
	var num int = 10
	switch num {
	case 10:
		fmt.Println("ok1")
		fallthrough // 默认只能穿透一层
	case 20:
		fmt.Println("ok2")
		fallthrough
	case 30:
		fmt.Println("ok3")
	default:
		fmt.Println("没用匹配到")
	}
}

10）Type Switch：switch 语句还可以被用于 type-switch来判断某个interface变量中实际指向的变量类型【还没有学interface，先体验一把】

package main
import (
	"fmt"
)
func main() {
	var x interface{}
	var y = 10.0
	x = y
	// x.(type)就是type的使用，这个时候会得到x真正指向的数据类型
	// x.type结合switch可以判断x这个空接口究竟是指向哪一种数据类型
	switch i := x.(type) {
	case nil:
		fmt.Println("x的类型为~ :%T",i)
	case int:
		fmt.Println("x是int类型")
	case float64:
		fmt.Println("x是float64类型")
	case func(int) float64:
		fmt.Println("x是func(int)类型")
	case bool, string:
		fmt.Println("x是bool或string类型")
	default:
		fmt.Println("未知类型")
	}
}