【第十一篇】一文搞懂_程序流程控制（上）🔥🔥

持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第3天，点击查看活动详情

一、程序流程控制介绍：

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主动有三大流程控制语句。

1. 顺序控制
2. 分支控制
3. 循环控制

二、顺序控制：

一、顺序控制介绍：

程序从上到下逐行执行，中间没有任何判断和跳转。

一个案例说明，必须从下面的代码中，没有判断，也没有跳转。因此程序按照默认的流程执行，即顺序控制。

二、顺序控制的一个流程图：

一、顺序控制举例和注意事项：

---

三、分支控制：

一、分支控制的基本介绍：

分支控制就是让程序有选择的执行。有下面三种形式：

1. 单分支
2. 双分支
3. 多分支

二、单分支控制：

1. 基本语法：
2. 应用案例：

1. 1. 编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责！”需求 --- > 分析 ---> 代码

package main

import "fmt"

func main() {
	// 编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责！”。
	// 否则，输出“你的年龄不大这次就放过你了”

	// 分析
	// 1. 年龄 ===> var age int
	// 2. 从控制台接收一个输入， fmt.Scanln(&age)
	// 3. if 判断

	var age int
	fmt.Println("请输入年龄：")
	fmt.Scanln(&age)

	if age > 18 {
		fmt.Println("你的年龄大于18，要对自己的行为负责 ！")
	}
}

3. 单分支流程图

1. 1. 流程图可以用图形方式来更加清晰的描述程序执行的流程。

4. 单分支的细节说明：

package main

import "fmt"

func main() {
	// 编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责！”。
	// 否则，输出“你的年龄不大这次就放过你了”

	// golang 支持在if中，直接定义一个变量：
	if age := 20; age > 18 {
		fmt.Println("你的年龄大于18，要对自己的行为负责 ！")
	}
}

三、双分支控制：

1. 基本语法

2. 应用案例：

1. 1. 编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责！”。否则，输出“你的年龄不大这次就放过你了”

package main

import "fmt"

func main() {

	// 编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责！”。
	// 否则，输出“你的年龄不大这次就放过你了”

	// 分析
	// 1. 年龄 ===> var age int
	// 2. 从控制台接收一个输入， fmt.Scanln(&age)
	// 3. if --- else 判断

	var age int
	fmt.Println("请输入年龄：")
	fmt.Scanln(&age)

	if age > 18 {
		fmt.Println("你的年龄大于 18 .....")
	} else {
		fmt.Println("你的年龄不大这次就放过你了")
	}
}

3. 双分支的流程图的分析

1. 1. 流程图可以用图形的方式来更加清晰的描述程序执行的过程。

4. 对双分支的总结：

1. 1. 从图上来看，表达式就是 age > 18
   2. 执行代码块1 ====> fmt.Println("你的年龄大于18")...
   3. 执行代码块2 ====> fmt.Println("你的年龄不大.....")
   4. 强调一下，双分支只会执行其中的一个分支。

四、单分支和双分支的案例：

1. 对下列代码，若有输出，指出输出结果。

2. 对下列代码，若有输出，指出输出结果。

3. 对下列代码，若有输出，指出输出结果。

4. 对下列代码，若有输出，指出输出结果。

5. 编写程序，声明两个int 32型变量并赋值。判断两数之和，如果大于等于50，打印“hello world !”

package main

import "fmt"

func main() {
	//	编写程序，声明两个int 32 型变量并赋值。判断两数之和，如果大于等于50 ，打印“hello world !”

	var n1 int32 = 10
	var n2 int32 = 50

	if n1+n2 >= 50 {
		fmt.Println("hello world")
	}
}

6. 编写程序，声明两个float 64型变量并赋值。判断一个数大于 10.0 ，且第二个数小于 20.0 ，打印两数之和。

package main

import "fmt"

func main() {
	// 编写程序，声明两个float 64型变量并赋值。判断一个数大于 10.0 ，且第二个数小于 20.0 ，打印两数之和。

	var n3 float64 = 11.0
	var n4 float64 = 17.0

	if n3 > 10.0 && n4 < 20.0 {
		fmt.Println("和= ", (n3 + n4))
	}
}

7. 【选作】定义两个变量 int 32 ，判断二者的和，是否能被3又被5整除，打印提示信息。

package main

import "fmt"

func main() {
	// 【选作】定义两个变量 int 32 ，判断二者的和，是否能被3又被5整除，打印提示信息。

	var num1 int32 = 10
	var num2 int32 = 5

	if (num1+num2)%3 == 0 && (num1+num2)%5 == 0 {
		fmt.Print("能被三又能被五整除")
	}
}

8. 判断一个年份是否是闰年，闰年的条件是符合下面二者之一：

1. 1. 1. 年份能被4整除，但是不能被100整除。
   2. 能被 400 整除。

package main

import "fmt"

func main() {
	// 判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
	// a. 1. 年份能被4整除，但是不能被100整除。
	// b. 能被 400 整除。

	var year int = 2020
	// 这里其实不加括号也是可以的，但是方便大家理解，加上了括号
	// 逻辑与的优先级高于逻辑或，所以没有括号也是可以的
	if (year%4 == 0 && year%100 != 0) || year%400 == 0 {
		fmt.Println("是闰年~")
	}
}

---

五、多分支控制：

1. 基本语法：

对上面基本语法的说明：

2. 多分支的判断流程如下：

1. 1. 先判断表示 1 是否成立 ，如果为真，就执行代码块 1
   2. 如果条件表达式 1 如果为假，就去判断条件表达式 2 是否成立，如果条件表达式 2 为真，就执行代码块 2
   3. 以此类推
   4. 如果所有条件表达式不成立，则执行 else 的语句块。

3. else 不是必须的
4. 多分支只能有一个执行入口
5. 看一个多分支的流程图（更加清晰）

6. 多分支的快速入门案例：

1. 1. 小王参加golang 考试，和他父亲大王达成承诺：
   2. 如果：
   3. 成绩为100分时候，奖励一个 BMW
   4. 成绩为（80,99】时，奖励一台 iPhone 14 Pro Max 暗紫色 1TB
   5. 当成绩为【60,80】时，奖励一个 iPad Pro
   6. 其它时，什么奖励都没有。
   7. 请问从键盘输入小王的期末成绩并加以判断。

package main

import (
	"fmt"
)

func main() {
	// a. 小王参加golang 考试，和他父亲大王达成承诺：
	// b. 如果：
	// c. 成绩为100分时候，奖励一个 BMW
	// d. 成绩为（80,99】时，奖励一台 iPhone 14 Pro Max 暗紫色 1TB
	// e. 当成绩为【60,80】时，奖励一个 iPad Pro
	// f. 其它时，什么奖励都没有。
	// g. 请问从键盘输入小王的期末成绩并加以判断。

	// 分析思路：
	// 1. score 分数 int
	// 2. 选择多分支流程控制：
	// 3. 成绩从键盘输入 fmt.Scanln

	var score int
	fmt.Println("请输入成绩：")
	fmt.Scanln(&score)

	// 多分支判断
	if score == 100 {
		fmt.Println("奖励一个 BMW")
	} else if score > 80 && score <= 99 {
		fmt.Println("奖励一台 iPhone 14 Pro Max 暗紫色 1TB")
	} else if score >= 60 && score <= 80 {
		fmt.Println("奖励一个 iPad Pro")
	} else {
		fmt.Println("奖励一七匹狼炒肉丝")
	}
}

7. 多分支的课堂练习：使用陷阱

package main

import (
	"fmt"
)

func main() {

	// 使用陷阱

	var n int = 10
	if n > 9 {
		fmt.Println("OK1")
	} else if n > 6 {
		fmt.Println("OK2")
	} else if n > 3 {
		fmt.Println("OK3")
	} else {
		fmt.Println("OK4")
	}

}

---

六、嵌套分支：

1. 基本介绍：

在一个分支结构中又完整的嵌套了另外一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。

2. 基本语法

3. 应用案例：

1. 1. 参加百米运动会，如果用时8秒以为进入决赛，否则提示淘汰。并且根据性别提示进入男子组或者女子组，输入成绩和性别。

package main

import "fmt"

func main() {
	// 参加百米运动会，如果用时8秒以为进入决赛，否则提示淘汰。
	// 并且根据性别提示进入男子组或者女子组，输入成绩和性别。

	// 分析思路：
	// 1. 定义一个变量，来接收跑步使用的秒数，float 64
	// 2. 定义一个变量，来接收性别string
	// 3. 因为判断是嵌套的判断，因此我们会使用嵌套分支const

	var second float64
	fmt.Println("请输入秒数：")
	fmt.Scanln(&second)

	if second <= 8 {
		// 进入决赛判断
		var gender string
		fmt.Println("请输入性别：")
		fmt.Scanln(&gender)
		if gender == "男" {
			fmt.Println("进入决赛的男子组")
		} else {
			fmt.Println("进入决赛的女子组")
		}
	} else {
		fmt.Println("out .....")
	}
}

1. 4. 出票系统：根据淡旺季的月份和年龄，打印票价：

1. 1. 1. 旺季：

1. 1. 1. 1. 成年 18 - 60 ：60 元
         2. 儿童 < 18 ：半价 30 元
         3. 老人 > 60 ：1/3 20元

1. 1. 2. 淡季：

1. 1. 1. 1. 成人：40 元
         2. 其他：20 元

package main

import "fmt"

func main() {

	// d. 出票系统：根据淡旺季的月份和年龄，打印票价：
	// ⅰ. 旺季：
	//   1. 成年 18 - 60 ：60 元
	//   2. 儿童  < 18 ：半价 30 元
	//   3. 老人 > 60 ：1/3 20元
	// ⅱ. 淡季：
	//   1. 成人：40 元
	//   2. 其他：20 元

	var month byte
	var age byte
	var price float64 = 60

	fmt.Println("请输入旅游的月份：")
	fmt.Scanln(&month)
	fmt.Println("请输入游客的年龄：")
	fmt.Scanln(&age)

	if month >= 4 && month <= 10 {
		if age > 60 {
			fmt.Printf("%v月份	年龄%v	票价：%v", month, age, price/3)
		} else if age >= 18 {
			fmt.Printf("%v月份	年龄%v	票价：%v", month, age, price)
		} else {
			fmt.Printf("%v月份	年龄%v	票价：%v", month, age, price/2)
		}
	} else {
		if age >= 18 && age < 60 {
			fmt.Println("淡季成人票价 40 ")
		} else {
			fmt.Println("淡季儿童和老人票价 20 ")
		}

	}
}