程序流程控制
程序流程控制介绍
在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。
1. 顺序控制
2. 分支控制
3. 循环控制
顺序控制
程序从上到下逐行地执行，中间没有任何判断和跳转。
顺序控制的一个流程图
顺序控制举例和注意事项
Golang 中定义变量时采用合法的前向引用。如：
func main() {
var num1 int = 10 //声明了 num1
var num2 int = num1 + 20 //使用 num1
fmt.Println(num2)
}
错误形式：
func main() {
var num2 int = num1 + 20 //使用 num1
var num1 int = 10 //声明 num1 (×)
fmt.Println(num2)
}
分支控制
分支控制的基本介绍
分支控制就是让程序有选择执行。有下面三种形式
1. 单分支
2. 双分支
3. 多分支
单分支控制
基本语法:
var age int
fmt.Println("请输入年龄:")
fmt.Scanln(&age)
if age > 18 {
fmt.Println("你年龄大于18,要对自己的行为负责!")
}
单分支的流程图
单分支的细节说明
//golang支持在if中，直接定义一个变量，比如下面
if age := 20; age > 18 {
fmt.Println("你年龄大于18,要对自己的行为负责!")
}
双分支控制
if age > 18 {
fmt.Println("你年龄大于18,要对自己的行为负责!")
} else {
fmt.Println("你年龄小于18,可以干坏事!")
}
双分支的流程图的分析
对双分支的总结
1. 从上图看 条件表达式就是 age >18
2. 执行代码块 1 ===> fmt.Println(“你的年龄大于 18”)
3. 执行代码块 2 ===> fmt.Println(“你的年龄不大….”)
4. 强调一下双分支只会执行其中的一个分支。
单分支和双分支的案例
多分支控制
对上面基本语法的说明
1. 多分支的判断流程如下:
1. 先判断条件表达式 1 是否成立，如果为真，就执行代码块 1
2. 如果条件表达式 1 如果为假，就去判断条件表达式 2 是否成立， 如果条件表达式 2 为真， 就执行代码块 2
3. 依次类推
4. 如果所有的条件表达式不成立，则执行 else 的语句块。
2. else 不是必须的。
3. 多分支只能有一个执行入口。
//多分支判断
if score == 100 {
fmt.Println("奖励一辆BMW")
} else if score > 80 && score <= 99 {
fmt.Println("奖励一台iphone7plus")
} else if score >= 60 && score <= 80 {
fmt.Println("奖励一个 iPad")
} else {
fmt.Println("什么都不奖励")
}
嵌套分支
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分 支外面的分支结构称为外层分支。
if second <= 8 {
//进入决赛
var gender string
fmt.Println("请输入性别")
fmt.Scanln(&gender)
if gender == "男" {
fmt.Println("进入决赛的男子组")
} else {
fmt.Println("进入决赛的女子组")
}
} else {
fmt.Println("out...")
}
switch 分支控制
1. switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上到下逐一测 试，直到匹配为止。
2. 匹配项后面也不需要再加 break
对上图的说明和总结
1. switch 的执行的流程是，先执行表达式，得到值，然后和 case 的表达式进行比较，如果相等， 就匹配到，然后执行对应的 case 的语句块，然后退出 switch 控制。
2. 如果 switch 的表达式的值没有和任何的 case 的表达式匹配成功，则执行 default 的语句块。执行后退出 switch 的控制
3. golang 的 case 后的表达式可以有多个，使用 逗号 间隔
4. golang 中的 case 语句块不需要写 break , 因为默认会有,即在默认情况下，当程序执行完 case 语 句块后，就直接退出该 switch 控制结构
//分析思路
//1. 定义一个变量接收字符
//2. 使用switch完成
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("周三，猴子爬雪山")
//...
default:
fmt.Println("输入有误...")
}
// 写一个非常简单的函数
func test(char byte) byte {
return char + 1
}
switch 的使用的注意事项和细节
1. case/switch 后是一个表达式( 即：常量值、变量、一个有返回值的函数等都可以)
2. case 后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致
3. case 后面可以带多个表达式，使用逗号间隔。比如 case 表达式 1, 表达式 2 …
var n1 int32 = 5
var n2 int32 = 20
switch n1 {
case n2, 10, 5 : // case 后面可以有多个表达式
fmt.Println("ok1")
case 90 :
fmt.Println("ok2~")
}
4. case 后面的表达式如果是常量值(字面量)，则要求不能重复
5. case 后面不需要带 break , 程序匹配到一个 case 后就会执行对应的代码块，然后退出 switch，如 果一个都匹配不到，则执行 default
6. default 语句不是必须的
7. switch 后也可以不带表达式，类似 if –else 分支来使用
//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 后也可以直接声明/定义一个变量，分号结束，不推荐
//switch 后也可以直接声明/定义一个变量，分号结束，不推荐
switch grade := 90; { // 在golang中，可以这样写
case grade > 90:
fmt.Println("成绩优秀~..")
case grade >= 70 && grade <= 90:
fmt.Println("成绩优良~...")
case grade >= 60 && grade < 70:
fmt.Println("成绩及格~...")
default:
fmt.Println("不及格~")
}
9. switch 穿透-fallthrough ，如果在 case 语句块后增加 fallthrough ,则会继续执行下一个 case，也 叫 switch 穿透
//switch 的穿透 fallthrought
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, 先体验一把】
switch 的课堂练习
1. 使用 switch 把小写类型的 char 型转为大写(键盘输入)。只转换 a, b, c, d, e. 其它的输出 “other”。
//使用 switch 把小写类型的 char型转为大写(键盘输入)。
//只转换 a, b, c, d, e. 其它的输出 “other”。
var char byte
fmt.Println("请输入一个字符..")
fmt.Scanf("%c", &char)
switch char {
case 'a':
fmt.Println("A")
case 'b':
fmt.Println("B")
case 'c':
fmt.Println("C")
case 'd':
fmt.Println("D")
case 'e':
fmt.Println("E")
default :
fmt.Println("other")
}
2. 对学生成绩大于 60 分的，输出“合格”。低于 60 分的，输出“不合格”。(注：输入的成绩不 能大于 100)
//对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
//(注：输入的成绩不能大于100)
var score float64
fmt.Println("请输入成绩")
fmt.Scanln(&score)
switch int(score / 60) {
case 1:
fmt.Println("及格")
case 0:
fmt.Println("不及格")
default:
fmt.Println("输入有误..")
}
switch 和 if 的比较
总结了什么情况下使用 switch ,什么情况下使用 if
1. 如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用 swtich语句，简洁高效。
2. 其他情况：对区间判断和结果为 bool 类型的判断，使用 if，if 的使用范围更广。
for 循环控制
//golang中，有循环控制语句来处理循环的执行某段代码的方法->for循环
//for循环快速入门
for i := 1; i <= 10; i++ {
fmt.Println("你好", i)
}
for 循环的基本语法
for 循环变量初始化; 循环条件; 循环变量迭代 {
循环操作(语句)
}
1. 对 for 循环来说，有四个要素：
2. 循环变量初始化
3. 循环条件
4. 循环操作(语句) ,有人也叫循环体。
5. 循环变量迭代
for 循环执行的顺序说明：
1. 执行循环变量初始化，比如 i := 1
2. 执行循环条件， 比如 i <= 10
3. 如果循环条件为真，就执行循环操作 :比如 fmt.Println(“….”)
4. 执行循环变量迭代 , 比如 i++
5. 反复执行 2, 3, 4 步骤，直到 循环条件为 False ，就退出 for 循环。
for 循环执行流程分析
for 循环的使用注意事项和细节讨论
循环条件是返回一个布尔值的表达式
//for循环的第二种写法
j := 1 //循环变量初始化
for j <= 10 { //循环条件
fmt.Println("你好，尚硅谷~", j)
j++ //循环变量迭代
}
//for循环的第三种写法, 这种写法通常会配合break使用
k := 1
for { // 这里也等价 for ; ; {
if k <= 10 {
fmt.Println("ok~~", k)
} else {
break //break就是跳出这个for循环
}
k++
}
Golang 提供 for-range 的方式，可以方便遍历字符串和数组(注: 数组的遍历，我们放到讲数组 的时候再讲解) ，案例说明如何遍历字符串。
传统:
//字符串遍历方式1-传统方式
var str string = "hello,world!北京"
for i := 0; i < len(str); i++ {
fmt.Printf("%c \n", str[i]) //使用到下标...
}
//字符串遍历方式1-传统方式
var str string = "hello,world!北京"
str2 := []rune(str) // 就是把 str 转成 []rune
for i := 0; i < len(str2); i++ {
fmt.Printf("%c \n", str2[i]) //使用到下标...
}
for-range:
//字符串遍历方式2-for-range
str = "abc~ok上海"
for index, val := range str {
fmt.Printf("index=%d, val=%c \n", index, val)
}
while 和 do..while 的实现
Go 语言没有 while 和 do…while 语法，这一点需要同学们注意一下，如果我们需要使用类似其它语 言(比如 java / c 的 while 和 do…while )，可以通过 for 循环来实现其使用效果。
while 循环的实现
//使用while方式输出10句 "hello,world"
//循环变量初始化
var i int = 1
for {
if i > 10 { //循环条件
break // 跳出for循环,结束for循环
}
fmt.Println("hello,world", i)
i++ //循环变量的迭代
}
fmt.Println("i=", i)
do..while 的实现
//使用的do...while实现完成输出10句”hello,ok“
var j int = 1
for {
fmt.Println("hello,ok", j)
j++ //循环变量的迭代
if j > 10 {
break //break 就是跳出for循环
}
}
多重循环控制(重点，难点)
1. 将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的 for 称为外层循环在里面的 for循环称为内层循环。【建议一般使用两层，最多不要超过 3 层】
2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
3. 外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次
var totalLevel int = 20
//i 表示层数
for i := 1; i <= totalLevel; i++ {
//在打印*前先打印空格
for k := 1; k <= totalLevel - i; k++ {
fmt.Print(" ")
}
//j 表示每层打印多少*
for j :=1; j <= 2 * i - 1; j++ {
if j == 1 || j == 2 * i - 1 || i == totalLevel {
fmt.Print("*")
} else {
fmt.Print(" ")
}
}
fmt.Println()
}
跳转控制语句-break
//随机生成1-100的一个数，直到生成了99这个数，看看你一共用了几次
//分析思路：
//编写一个无限循环的控制，然后不停的随机生成数，当生成了99时，就退出这个无限循环==》break
var count int = 0
for {
rand.Seed(time.Now().UnixNano())
n := rand.Intn(100) + 1
fmt.Println("n=", n)
count++
if (n == 99) {
break //表示跳出for循环
}
}
以 for 循环使用 break 为例,画出示意图
break 的注意事项和使用细节
break 语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
//这里演示一下指定标签的形式来使用 break
lable2:
for i := 0; i < 4; i++ {
//lable1: // 设置一个标签
for j := 0; j < 10; j++ {
if j == 2 {
//break // break 默认会跳出最近的for循环
//break lable1
break lable2 // j=0 j=1
}
fmt.Println("j=", j)
}
}
1. break 默认会跳出最近的 for 循环
2. break 后面可以指定标签，跳出标签对应的 for 循环
跳转控制语句-continue
1. continue 语句用于结束本次循环，继续执行下一次循环。
2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这 个和前面的 break 标签的使用的规则一样
continue 流程图
here:
for i := 0; i < 2; i++ {
for j := 1; j < 4; j++ {
if j == 2 {
continue here
}
fmt.Println("i=", i, "j=", j)
}
}
跳转控制语句-goto
1. Go 语言的 goto 语句可以无条件地转移到程序中指定的行。
2. goto 语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能。
3. 在 Go 程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序 都产生困难
goto 的流程图
var n int = 30
//演示goto的使用
fmt.Println("ok1")
if n > 20 {
goto label1
}
fmt.Println("ok2")
fmt.Println("ok3")
fmt.Println("ok4")
label1:
fmt.Println("ok5")
fmt.Println("ok6")
fmt.Println("ok7")
跳转控制语句-return
return 使用在方法或者函数中，表示跳出所在的方法或函数，在讲解函数的时候，会详细的介绍
var n int = 30
//演示return的使用
fmt.Println("ok1")
if n > 20 {
return
}
fmt.Println("ok2")
fmt.Println("ok3")
fmt.Println("ok4")
fmt.Println("ok5")
fmt.Println("ok6")
fmt.Println("ok7")
1. 如果 return 是在普通的函数，则表示跳出该函数，即不再执行函数中 return 后面代码，也可以 理解成终止函数。
2. 如果 return 是在 main 函数，表示终止 main 函数，也就是说终止程序。
![[应用出海] Google Play 从 0 到应用上架-五八三](https://583.cn/wp-content/uploads/2023/08/8d2769d12c55afd455b8b6c7de61c02f.jpg)
