五、流程控制语句

程序是由语句构成，而流程控制语句是用来控制程序中每条语句执行顺序的语句。可以通过控制语句实现更丰富的逻辑以及更强大的功能。几乎所有编程语言都有流程控制语句，功能也都基本相似。

其流程控制方式有

顺序结构
分支结构
循环结构

这里最简单最常用的就是顺序结构，即语句从上至下一一执行。

5.1、分支语句

顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构。

5.1.1、单分支语句

语法：

if 布尔表达式 {  // 注意左花括号必须与表达式同行
   /* 在布尔表达式为 true 时执行 */
}
/*
当条件表达式true时，就会执行得的代码。
ps: 条件表达式左右的()可以不写，也建议不写
ps: if和表达式中间，一定要有空格
ps: 在Golang中，{}是必须有的，就算你只写一行代码。
*/

package main

import "fmt"

func main() {
	// 实现功能： 如果口罩的库存小于30，提示：库存不足
	var conut int = 100
	// 单分支：
	if conut < 30 {
		fmt.Println("对不起，口罩存量不足")
	}
	// if 后面表达式，返回结果一定是true或者是false
	// 如果返回结果true的话，那么{}中的代码就会执行
	// 如果返回结果为false的话，那么{}中的代码就不会执行
	// if后面颐堤港要有空格，和条件表达式分隔开来
	// {}一定不能省略
	// 条件表达式左右的()是建议省略的
	// 在golang里，if后面可以并列的加入变量的定义：

	if conut := 20; conut < 30 {
		fmt.Println("对不起，口罩村存量不足")
	}
}

5.1.2、双分支语句

双分支语句顾名思义，两条分支二选一执行！

package main

import "fmt"

func main() {
	// 实现功能。如果口罩的库存小于30个，提示：库存不足，否则提示，库存不足
	// 定义口罩的数量
	var count int = 30
	if count < 30 { //  这个条件表达式返回的是true的话，后面{}执行了
		fmt.Println("库存不足")
	} else {
		fmt.Println("库存不足")
	}

	// 双分支一定会是二选一走其中一个分支
}
package main

import "fmt"

func main() {
	// 实现功能。如果口罩的库存小于30个，提示：库存不足，否则提示，库存不足
	// 定义口罩的数量
	var count int = 30
	if count < 30 { //  这个条件表达式返回的是true的话，后面{}执行了
		fmt.Println("库存不足")
	} else {
		fmt.Println("库存不足")
	}

	// 双分支一定会是二选一走其中一个分支
}

5.1.3、if多分支语句

多分支即从比双分支更多的分支选择一支执行。

不管多少条分支只能执行一条分支！

package main

import "fmt"

func main() {
	// 实现功能，根据给出的学生分支， 判断学生的等级
	// >= 90  -----A
	// >= 80  -----B
	// >= 70  -----C
	// >= 60  -----D
	// <60  -----E

	// 定义一个学生的成绩
	var score int = 93
	if score >= 90 {
		fmt.Println("您的成绩为A级别")
	} else if score >= 80 {
		fmt.Println("您的成绩为B级别")
	} else if score >= 70 {
		fmt.Println("您的成绩为C级别")
	} else if score >= 60 {
		fmt.Println("您的成绩为C级别")
	} else if score < 60 {
		fmt.Println("您的成绩为E级别")
	} // 建议你保证else的存在，只有有了else才会真正，气到多选一的效果
}

5.1.4、switch多分支语句

switch语句也是多分支选择语句，执行哪一条代码块，取决于switch后的值与哪一case的值匹配成功，则执行改case后的代码块

注意事项：

switch后是一个表达式（即：常量值，变量，一个有返回值的函数等都可以）
case后的各个值的数据类型，必须和switch的表达式数据类型一致。
case后面可以带多个表达式，使用逗号间隔，比如case表达式1、表达式2...
case后面的的表达式如果是常量值(字面量)，则要求不能重复
case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default
default语句不是必须的。
switch后也可以不带表达式，当做if分支来使用。
switch后也可以执行声明/定义一个变量，分好结束，不推荐
switch穿透，利用fallthrough关键字，如果case语句块后增加fallthrough，则会继续执行下一个case，也叫switch穿透

package main

import "fmt"

func main() {
	// 实现功能，根据给出的学生分支， 判断学生的等级
	// >= 90  -----A
	// >= 80  -----B
	// >= 70  -----C
	// >= 60  -----D
	// <60  -----E

	// 定义一个学生的成绩
	var score int = 87
	// 根据分数判断等级：

	// switch后面是一个表达式，这个表达式的结果依次跟case进行比较，满足结果的话就执行冒号后面的代码块
	// default是用来"兜底"的一个分支，其他case分之都不走的情况下就会default分之
	// default分之可以放在任意位置上， 不一定非要放在最后
	switch score / 10 {
	case 10:
		fmt.Println("您的等级为A")
	case 9:
		fmt.Println("您的等级为B")
	case 8:
		fmt.Println("您的等级为C")
	case 7:
		fmt.Println("您的等级为D")
	case 6:
		fmt.Println("您的等级为E")
	default:
		fmt.Println("您的成绩有误")

	}
}

1、switch比if else更为简洁

2、执行效率更高。switch…case会生成一个跳转表来指示实际的case分支的地址，而这个跳转表的索引号与switch变量的值是相等的。从而，switch…case不用像if…else那样遍历条件分支直到命中条件，而只需访问对应索引号的表项从而到达定位分支的目的。

3、到底使用哪一个选择语句，代码环境有关，如果是范围取值，则使用if else语句更为快捷；如果是确定取值，则使用switch是更优方案。

switch同时支持多条件匹配：

strconv.ParseBool() 源码查看

5.2、循环语句

在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，决定循环的终止条件。

与其它主流编程语言不同的的是，Go语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构。

5.2.1、for循环

原始for循环

通过关系表达式或逻辑表达式控制循环

package main

import "fmt"

func main() {
	// 实现一个功能：求和 1+2+3+4+5+...10
	// 定义变量：
	// 求和：
	// 定一个一个变量。用来接受这个求和
	// 利用for循环来解决问题；
	var sum int = 0

	for i := 1; i <= 10; i++ {
		sum += i
	}
	// 输出结果
	fmt.Println(sum)

	// for 循环的语法格式；
	// for 初始化表达式，布尔表达式（条件表达式）；迭代因予 {
	// 循环体; --> 反复重复执行的内容

	// 注意： for的初始表达式，不能用var定义变量的形式，要用:=
	// 注意： for循环实际就是让程序元写代码的效率高了, 但是底层改怎么执行的，底层效率没有提高，只是程序员写代码简洁了
}

for循环的细节

三要素for循环（核心）

将初始化语句、条件判断以及步进语句格式固定化的循环方式，本质上和上面的for循环没有区别。

package main

import "fmt"

func main() {
	i := 2       // 变量的初始化
	for i < 10 { // 条件表达式。判断条件
		fmt.Println("你好 gloang") // 循环体
		i++                      // 迭代
	}
}

init：初始化语句,一般为赋值表达式，给控制变量赋初值;
condition：条件判断，一般是关系表达式或逻辑表达式，循环控制条件;
post：步进语句，一般为赋值表达式，给控制变量增量或减量。

执行流程（关键）：

（1）初始语句

（2）条件判断，布尔值为真则执行一次循环体，为假则退出循环

（3）执行一次循环体语句结束后，再执行步进语句，然后回到步骤（2），依次循环

通过for循环变成死循环

package main

import "fmt"

func main() {
	// 死循环：
	for {
		fmt.Println("你好golang")
	}
}

for range结构是Go语言特有的一种的迭代结构，在许多情况下都非常有用，for range可以遍历数组，切片，字符串、map即通道，for range语法上类似的其他语言foreach语句，一般形式为：

// 方式一
package main

import "fmt"

func main() {
	// 定义一个字符串
	var str string = "hello golang"
	// 方式1： 普通for循环   按照字节进行遍历输出的
	for i := 0; i < len(str); i++ { // i： 理解为字符的下标
		fmt.Printf("%c", str[i])
	}
}

// 方式二
package main

import "fmt"

func main() {
	// 定义一个字符串
	var str string = "hello golang你好"
	// 方式2: for range
	for i, value := range str {
		fmt.Printf("索引为：%d 具体的值为：%c \n", i, value)
	}

	// 对str进行遍历，遍历的每个结果的 索引被i接收，每个结果的具体数值为value接收
	// 遍历对字符进行遍历的
}

打印的结果

索引为：0 具体的值为：h 
索引为：1 具体的值为：e 
索引为：2 具体的值为：l 
索引为：3 具体的值为：l 
索引为：4 具体的值为：o 
索引为：5 具体的值为：  
索引为：6 具体的值为：g 
索引为：7 具体的值为：o 
索引为：8 具体的值为：l 
索引为：9 具体的值为：a 
索引为：10 具体的值为：n 
索引为：11 具体的值为：g 
索引为：12 具体的值为：你 
索引为：15 具体的值为：好

for循环关键字break

当break 关键字用于 for 循环时，会终止循环而执行整个循环语句后面的代码。break 关键字通常和 if 语句一起使用，即满足某个条件时便跳出循环，继续执行循环语句下面的代码。

package main

import "fmt"

func main() {
	// 功能：求1——100的和，当和第一次超过300的时候，停止程序
	var sum int = 0
	for i := 1; i <= 100; i++ {
		sum += i
		fmt.Println(sum)
		if sum >= 300 {
			// 停止正在执行的这个循环，
			break
		}
	}
	fmt.Println("--------ok")
}

总结：

switch分支中，每个case分之后面都用break结束当前分之，但是在go语言中break可以省略不写。

2.break可以结束正在执行的循环

break的作用

在一个循环体语句中又包含另一个循环语句，称为循环嵌套

package main

import "fmt"

func main() {
	//双重循环
	for i := 1; i <= 5; i++ {
		for j := 2; j <= 4; j++ {
			fmt.Printf("i: %v, j: %v \n", i, j)
			if i == 2 && j == 2 {
				break
			}
		}
	}
}

总结： break的作用结束离它最近的循环

标签的使用展示

package main

import "fmt"

func main() {
	//双重循环
lable2:
	for i := 1; i <= 5; i++ {
		for j := 2; j <= 4; j++ {
			fmt.Printf("i: %v, j: %v \n", i, j)
			if i == 2 && j == 2 {
				break lable2 // 结束指定标签的对应循环
			}
		}
	}
	fmt.Println("----OK----")
}

注意：如果那个标签没有使用到的话，那么标签不用加，否则报错，定义未使用

打印结果

i: 1, j: 2 
i: 1, j: 3 
i: 1, j: 4 
i: 2, j: 2

continue的作用

break 语句使得循环语句还没有完全执行完就提前结束，与之相反，continue 语句并不终止当前的循环语句的执行，仅仅是终止当前循环变量 i 所控制的这一次循环，而继续执行该循环语句。continue 语句的实际含义是“忽略 continue 之后的所有循环体语句，回到循环的顶部并开始下一次循环”

package main

import "fmt"

func main() {
	// 功能： 输出1-100中被6整除的数：
	for i := 1; i <= 100; i++ {
		if i%6 != 0 {
			continue  // 结束本次循环，继续下一次循环
		}
		fmt.Println(i)
	}
}

总结：continue的作用是结束离它最近的那个循环，继续执行离它近哪个循环。

goto关键字

gllang的 goto语句可以无条件的转移到程序中指定的行。

goto语句通常与条件语句配合使用。可用来实现条件转移。

在go程序设计中一班不建议使用goto语句，以免造成程序流程混乱

代码练习：

package main

import "fmt"

func main() {
	fmt.Println("hello summer golang1")
	fmt.Println("hello summer golang2")
	if 1 == 1 {
		goto label1 // goto一般配合条件结构一起使用
	}
	fmt.Println("hello summer golang3")
	fmt.Println("hello summer golang4")
label1:
	fmt.Println("hello summer golang5")
	fmt.Println("hello summer golang6")
}

return关键字

package main

import "fmt"

func main() {
	for i := 1; i <= 100; i++ {
		fmt.Println(i)
		if i == 14 {
			return // 结束当前的函数
		}
	}
	fmt.Println("hello golang")
}

posted @ 2022-11-05 15:23 xiaohaoge 阅读(164) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 五、流程控制语句

· 四、基础语法

· Golang基础-流程控制

· Go流程控制

· 05Go语言基础之流程控制

花海

朝碧海而暮苍梧，睹青天而攀白日

五、流程控制语句

五、流程控制语句

5.1、分支语句

5.1.1、单分支语句

5.1.2、双分支语句

5.1.3、if多分支语句

5.1.4、switch多分支语句

5.2、循环语句

5.2.1、for循环

原始for循环

三要素for循环（核心）

for循环关键字break

break的作用

标签的使用展示

continue的作用

goto关键字

return关键字

公告

积分与排名

随笔分类