【GO】06_顺序控制语句和分支控制语句(if、else、switch)

文章目录

顺序控制语句

顺序控制是指程序从上到下逐行地执行，中间没有任何判断和跳转。其流程图如下所示：

代码中没有判断，程序按照默认的流程执行，即顺序控制。

分支控制语句(条件控制语句)

单分支
- 基本语法如下：
```
if 条件表达式 {
	执行代码块
}
```
- 对应的流程图如下所示：
- 说明：
  - 当条件表达式为True时，就会执行括号中的代码块。
  - 注意{}是必须有的，即使只写一行代码。
  - 在golang中支持在if语句直接定义一个变量，该变量的作用域只能在该条件逻辑块内起作用，如下所示：
```
if n := 20; n > 5 {
	fmt.Println("定义变量的值数字大于5")
}
```
双分支
- 基本语法如下：
```
if 条件表达式 {
	执行代码块1
} else {
	执行代码块2
}
```
- 对应的流程图如下所示：
- 说明：
  - 当条件表达式为True时，否则执行代码块2。
  - 注意{}是必须有的，即使只写一行代码。
  - 双分支只会执行其中一个分支
多分支
- 基本语法如下：
```
if 条件表达式1 {
	执行代码块1
} else if 条件表达式2 {
	执行代码块2
}
...
 else {
 	执行代码块n
}
```
- 对应的流程图如下所示：
- 说明：
  - 先判断条件表达式1是否成立，如果为True，就执行代码块1
  - 如果条件表达式1位False，就去判断条件表达式2是否成立，如果条件表达式2成立，就执行代码块2
  - 依次类推，如果所有的条件表达式不成立，就执行else语句块
  - else不是必须的
  - 注意：多分支语句只能有一个执行入口
- 判定学生成绩
```
package main

import "fmt"

func main() {
	//输入变量
	var score int
	fmt.Println("请输入成绩:")
	fmt.Scanln(&score)

	//多分支判断
	if score >= 90 {
		fmt.Println("该同学成绩为A")
	} else if score >= 80 && score < 90 {
		fmt.Println("该同学成绩为B")
	} else if score >= 70 && score < 80 {
		fmt.Println("该同学成绩为C")
	} else if score >= 60 && score < 70 {
		fmt.Println("该同学成绩为D")
	} else {
		fmt.Println("该同学成绩为E")
	}
	fmt.Printf("成绩为:%d", score)
}
```
- 使用陷阱

嵌套分支

在一个分支结果中又完整嵌套另一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外层分支。基本语法如下:

if 条件表达式 {
	if 条件表达式 {
		语句块
	} else {
		语句块
	}
	....
}

注意事项：

嵌套分支不宜过多，建议控制在三层内

应用案例:

参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰；并且根据性别提示进入男子组或女子组，我们输入成绩和性别进行相关判断。

package main

import "fmt"

func main() {
	var sex string
	var second float64

	fmt.Println("请输入秒数:")
	fmt.Scanln(&second)

	//嵌套分支
	if second <= 8 {
		fmt.Println("请输入性别:")
		fmt.Scanln(&sex)
		if sex == "男" {
			fmt.Println("进入决赛的男子组")
		} else if sex == "女" {
			fmt.Println("进入决赛的女子组")
		} else {
			fmt.Println("性别输入错误")
		}
	} else {
		fmt.Println("淘汰未进入决赛")
	}
}

switch分支控制

switch语句用于基于不同条件执行不同动作，每个case分支都是唯一的，从上往下逐一测试，直到匹配为止。注意，匹配项后面不需要再加break。
- 基本语法如下：
```
switch 表达式 {

case 表达式1, 表达式2, ...:
	语句块1
case 表达式3, 表达式4, ...:
	语句块2
	....
default:
    语句块n
}
```
- 对应的流程图如下所示：
- 说明：
  - switch的执行流程是先执行表达式，得到值，然后和case的表达式进行比较，如果相等，就匹配到；接着执行对应case的语句块，然后退出switch控制。
  - 如果switch表达式的值没有和任何case的表达式匹配成功，则执行default的语句块，执行后退出switch的控制。
  - golang中的case后的表达式可以有多个，使用逗号间隔。
  - golang中的case语句块不需要写break，因为默认会有。即在默认情况下，当程序执行完case语句块后，就直接退出该switch控制结构。
- 案例
  
  请编写程序实现输入某个字符，然后a表示周一，b表示周二，c表示周三，根据用户的输入依次显示信息。
```
package main

import "fmt"

func main() {
	var key byte
	fmt.Println("请输入a到g的一个字符")
	fmt.Scanf("%c", &key)

	//switch语句
	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("输入有误....")
	}
}
```
- 细节讨论
  1. case和switch后是一个表达式，即常量值、变量、一个有返回值的函数等
  2. case后的各个表达式值的数据类型，必须和switch的表达式数据类型一致
  3. case后面可以带多个表达式，使用逗号间隔
  4. case后的表达式如果是常量值，则要求不能重复，如果这个5是个变量就可以
  5. case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default
  6. default语句不是必须的
  7. switch后也可以不带表达式，类似于if-else分支来使用；同时case中也可以对范围进行判断
```
package main

import "fmt"

func main() {
	//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("没有匹配到")
	}

	//case中也可以对范围进行判断
	var score int = 90
	switch {
	case score >= 90:
		fmt.Println("成绩A")
	case score >= 70 && score < 90:
		fmt.Println("成绩B")
	case score >= 60 && score <= 70:
		fmt.Println("成绩C")
	default:
		fmt.Println("成绩D")
	}
}
```
  8. switch后也可以直接声明定义变量，分好结束，但不推荐使用。
  9. switch穿透fallthrough。如果在case语句块后增加fallthrough，则会继续执行下一个case，也叫switch穿透。
```
package main

import "fmt"

func main() {
	//switch穿透fallthrough
	var age int = 10

	switch age {
	case 5:
		fmt.Println("年龄为5")
		fallthrough //默认只能穿透一层
	case 10:
		fmt.Println("年龄为10")
		fallthrough //默认只能穿透一层
	case 20:
		fmt.Println("年龄为20")
		fallthrough
	case 30:
		fmt.Println("年龄为30")
	default:
		fmt.Println("没有匹配到")
	}
}
```
  10. Type Switch。switch语句还可以被用于type-switch来判断某个interface（接口）变量中实际指向的变量类型。
```
package main

import "fmt"

func main() {
	//type-switch
	var x interface{} //定义空接口
	var y = 10.0
	x = y

	switch i := x.(type) {
	case nil:
		fmt.Printf("x的类型是:%T", i)
	case int:
		fmt.Printf("x是int型")
	case float64:
		fmt.Printf("x是float64型") //输出结果
	case func(int) float64:
		fmt.Printf("x是func(int)型")
	case bool, string:
		fmt.Printf("x是bool或string型")
	default:
		fmt.Println("未知类型")
	}
}
```