go 语言流程控制

1. 流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块

控制语句的分类

控制语句分为三类： 顺序、选择和循环

顺序结构 代表先执行a,在执行b的逻辑

条件判断结构:代表"如果...,则..."的逻辑

三种流程控制语句能表示所有的事情！

循环结构:代表"重复执行..."的逻辑

基本语法

if 条件表达式{

}

当条件成立时，执行大括号内的代码

PS：条件表达式左右的()是可选的;不建议写

PS：if和表达式中间一定要有空格

PS: 在go语言中，{}是必须有的，就算只有一行代码也要有{}，不能省略

单分支语句

package main

import "fmt"

func main() {
	// 如果口罩库存少于30个就提醒不足
	var n1 int
	fmt.Println("请输入口罩库存数量：")
	fmt.Scanln(&n1)
	if n1 > 30 {
		fmt.Println("口罩库存充足")
	} /* else {
		fmt.Println("口罩库存不足")
	} */
	// if 表达式，返回结果必须是true 或者 false
	// 如果返回值是true，就执行大括号内的代码
	// 如果返回值是false，就不执行大括号内的代码；会执行后续
	//if 后{}不能省略
	//条件表达式左右（）是可选的；建议省略
	//在整个go语言里，if后面可以并列加入变量的定义
	if count := 10; count > 5 {
		fmt.Println("count is greater than 5")
	}

/* 执行结果
D:\golang\goproject\src\src01>go run demo23\main.go
请输入口罩库存数量：
40
口罩库存充足
count is greater than 5 */
}

 

双分支语句

if 条件表达式 {

    // 条件成立时执行的代码

} else {

    // 条件不成立时执行的代码

}

package main
import "fmt"
func main() {
	var num1 int
	fmt.Println("请输入数字:")
	fmt.Scanln(&num1)
	if num1 > 30 {
		fmt.Println("数量充足")
	} else {
		fmt.Println("数量不足")
	}
/* 执行结果
D:\golang\goproject\src\src01>go run demo24\main.go
请输入数字:
80
数量充足 */

}

多分支语句

if 条件表达式 {

    // 条件1成立时执行的代码

} else if 条件表达式 {

    // 条件2成立时执行的代码

} else {

    // 所有条件都不成立时执行的代码

}

 

package main
import "fmt"
func main() {
	//实现功能：根据给出的学生分数，判断学生登记
	var score int
	fmt.Println("请输入学生分数:")
	fmt.Scanln(&score)
	if score >= 90 {
		fmt.Println("学生成绩优秀")
	} else if score >= 80 {
		fmt.Println("学生成绩良好")
	} else if score >= 70{
		fmt.Println("学生成绩中等")
	} else  if score >= 60{
		fmt.Println("学生成绩及格")		
	 } else {
		fmt.Println("学生成绩不及格")
		
	}
/* 	执行结果
	D:\golang\goproject\src\src01>go run demo25\main.go
请输入学生分数:
89
学生成绩良好

D:\golang\goproject\src\src01>go run demo25\main.go
请输入学生分数:
100
学生成绩优秀

D:\golang\goproject\src\src01>go run demo25\main.go
请输入学生分数:
76
学生成绩中等

D:\golang\goproject\src\src01>go run demo25\main.go
请输入学生分数:
65
学生成绩及格

D:\golang\goproject\src\src01>go run demo25\main.go
请输入学生分数:
45
学生成绩不及格 */

}

　　switch 控制

基本语法

switch 表达式 {

case 值1:

    // 处理值1的情况

case 值2:

    // 处理值2的情况

default:

    // 处理其他情况

}

// switch 语句的特点

1. switch 语句可以有多个 case 分支，每个 case 分支可以有不同的值。

2. switch 语句会从上到下依次检查每个 case 分支，直到找到匹配的 case 分支为止。

3. 如果没有匹配的 case 分支，且存在 default 分支，则执行 default 分支的代码。

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

case 后的各个值的类型必须与switch 后表达式数据类型一致

case 后面可以带多个表达式，用逗号分隔，比如case 1, 2, 3:

case 后面不需要break,程序匹配到一个case后执行完成就会跳出switch语句，如果匹配不到任何一个case，则执行default分支

default 语句不是必须的，如果没有匹配到任何 case，且没有 default 分支，则 switch 语句不会执行任何代码。

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

switch 后语句可以不带表达式，当做if语句使用

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

switch 穿透，利用fallthrough 关键字，如果在case语句后面增加fallthrough,则会继续执行下一个case的代码，也叫做穿透

 

package main
import "fmt"
func main(){
	var score int
	fmt.Println("请输入你的成绩")
	fmt.Scanln(&score)
	switch score/10 {
		case 10:
			fmt.Println("等级为A+")
		case 9:
			fmt.Println("等级为A")
		case 8:
			fmt.Println("等级为B")
		case 7:
			fmt.Println("等级为c")
		case 6:
			fmt.Println("等级为D")
		case 5,4,3,2,1:
			fmt.Println("等级为E")
		default:
			fmt.Println("输入有误")
		
	}
}
----------------------
执行结果
D:\golang\goproject\src\src01>go run demo26\main1.go
请输入你的成绩
90
等级为A

D:\golang\goproject\src\src01>go run demo26\main1.go
请输入你的成绩
34
等级为E

D:\golang\goproject\src\src01>go run demo26\main1.go
请输入你的成绩
78
等级为c

D:\golang\goproject\src\src01>go run demo26\main1.go
请输入你的成绩
567
输入有误

　　穿透

package main
import "fmt"
func main() {
	//
	var  score int = 78
	/* fmt.Println("请输入学生分数:")
	fmt.Scanln(&score) */
	switch score/10 {
	case 10 :
		fmt.Println("学生成绩A")
	case 9 :
		fmt.Println("学生成绩B")
	case 8 :
		fmt.Println("学生成绩C")
	case 7 :
		fmt.Println("学生成绩D")
		fallthrough//只穿透一层
	case 6 :
		fmt.Println("学生成绩E")
	case 5 :
		fmt.Println("学生成绩F")
	case 4 :
		fmt.Println("学生成绩G")
	case 3 :
		fmt.Println("学生成绩H")
	case 2 :
		fmt.Println("学生成绩I")
	case 1 :
		fmt.Println("学生成绩J")
	}

	/* 执行结果
	D:\golang\goproject\src\src01>go run demo26\main.go
学生成绩D
学生成绩E */
}

　　 for 循环

语法表达式
for 初始化表达式; 布尔表达式; 迭代因子{
循环体
}
for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构，for 循环在第一次反复之前要进行初始化，即执行初始化表达式，随后对布尔表达式进行判断。若为true则执行循环体，否则终止，最后在每一次反复的时候，进行某种形式的步进，即迭代因子
1.初始化部分设置循环变量的初值
2.条件判断部分为任意布尔表达式
3.迭代因子控制变量的增减
for 循环在执行条件判定后，如果结果为true，先执行循环体部分，在执行步进
for 循环

package  main
import "fmt"
func main() {
	count := 6
	var sum int
	for i := 1; i < count; i++ {
	sum +=i
	}
	fmt.Println(sum)
}
--------------------------------------------
执行结果
D:\golang\goproject\src\src01>go run demo27\main.go
15

　　另一种写法

package  main
import "fmt"
func main() {
/* 	var count int
	fmt.Println("输入数字")
	fmt.Scanln(&count)
	//count := 6
	var sum int
	for i := 1; i < count; i++ { // for 的初始值不能用var定义变量的形式，要用 := 
	sum +=i
	}
	fmt.Println(sum) */
	i := 1 //变量初始化
	for i<6 { //判断表达式
		fmt.Println("golang")//循环体
		i++ //迭代条件
	}
}
---------------------------------------------
执行结果
D:\golang\goproject\src\src01>go run demo27/main.go
golang
golang
golang
golang
golang

　　for 循环实现死循环

package  main
import "fmt"
func main() {
	for ;;{
		fmt.Println(1)
	}
}

　　for range 

 

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

for key,val := range coll {

   

}

 

package main
import "fmt"
func main(){
	//定义一个字符串
	var str string = "hello Golang"
	//
	/* for i := 0 ; i < len(str);i++{ // len()
		fmt.Printf("%c\n",str[i])
	} */
	for i , value := range str {
		fmt.Printf("索引为：%d\n",i)
		fmt.Printf("值:%c\n",value)
	} 
	//对str进行遍历，遍历的每个结果的索引值被i接收，每个结果的具体值被value
	//对字符串进行遍历

}

/* 执行结果
D:\golang\goproject\src\src01>go run demo28\main.go
索引为：0
值:h
索引为：1
值:e
索引为：2
值:l
索引为：3
值:l
索引为：4
值:o
索引为：5
值:
索引为：6
值:G
索引为：7
值:o
索引为：8
值:l
索引为：9
值:a
索引为：10
值:n
索引为：11
值:g */

　　关键字break

感受break 在循环中的作用

1.在switch分支，每个case分支后都用break结束当前分支，但在go语言里break在结束当前分支可以省略

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

深入理解

break 默认只介绍离他近的循环;

package main
import "fmt"
func main(){
	//功能：求1~100的和。当和超过300的时候，停止程序
	var qwe int
	var r int
	fmt.Println("输入最终数字")
	fmt.Scanln(&r)
	fmt.Println("输入停止数字")
	fmt.Scanln(&qwe)
	//var c bool = true
	var sum int
	//var f int 
	for i :=0; i<=r ; i++{
		sum = sum +i
		if sum >= qwe  {
			//fmt.Println("数字",i,"和",sum)
	//		fmt.println(sum)
			break //停止正在执行的循环体

		} 
		fmt.Println("数字",i,"和",sum)

	}
	
}
/* 执行结果
D:\golang\goproject\src\src01>go run demo29\main.go
输入最终数字
29
输入停止数字
10
数字 0 和 0
数字 1 和 1
数字 2 和 3
数字 3 和 6 */

　　

标签的使用1

如果想要结束外层循环在外

package main
import "fmt"
func main(){
	// 双重循环
	var sum int
	//lable1:  //标签。指定跳出那一层的标签，默认只跳出当前层
	for i :=1 ;i <10; i++{
		for q :=0 ; q <=i;q++{
			sum = i + q
			if sum >= 5 {
				
				break

			}
			fmt.Println("和",sum)
		}
		fmt.Println("i:",i,"*********************************")
	}
	fmt.Println("结束",sum)
}
执行结果----------------------------------------------------
D:\golang\goproject\src\src01>go run demo30\main.go
和 1
和 2
i: 1 *********************************
和 2
和 3
和 4
i: 2 *********************************
和 3
和 4
i: 3 *********************************
和 4
i: 4 *********************************
i: 5 *********************************
i: 6 *********************************
i: 7 *********************************
i: 8 *********************************
i: 9 *********************************
结束 9

　　

层循环添加标签，在break后面指定标签

package main
import "fmt"
func main(){
	// 双重循环
	var sum int
	lable1:  //标签。指定跳出那一层的标签，默认只跳出当前层
	for i :=1 ;i <10; i++{
		for q :=0 ; q <=i;q++{
			sum = i + q
			if sum >= 5 {
				break lable1 // 只停止1层，当前层循环内层
			}
			fmt.Println("和",sum)
		}
		fmt.Println("i:",i,"*********************************")
	}
	fmt.Println("结束",sum)
}
执行结果-----------------------------------
D:\golang\goproject\src\src01>go run demo30\main.go
和 1
和 2
i: 1 *********************************
和 2
和 3
和 4
i: 2 *********************************
和 3
和 4
结束 5

　　continue 关键字结束本次循环

 

package main
import "fmt"
func main() {
	//输出1~100 中被6整除的数
	//方式1
	for i := 1 ;i <=100;i++{
		if i%6==0 {
			fmt.Println(i)
		}
	}
	fmt.Println("------------------------------------方式2--------------------------")
	for i := 1;i<=100;i++{
		if i%6 != 0{
			continue //跳过本次次循环，开始下一次循环
		}
		fmt.Println(i)
	}
}
执行结果
D:\golang\goproject\src\src01>go run demo31\main.go
6
12
18
24
30
36
42
48
54
60
66
72
78
84
90
96
------------------------------------方式2--------------------------
6
12
18
24
30
36
42
48
54
60
66
72
78
84
90
96

　　

goto 关键字

package main
import "fmt"
func main(){
	fmt.Println("hello  go 1")
	if 1==1{
	goto label1  //指定的标签
	}
	fmt.Println("hello  go xi")
	fmt.Println("hello  go feng")
	fmt.Println("hello  go lei")
	fmt.Println("hello  go ke")
	label1:
	fmt.Println("hello  go ming")
	fmt.Println("hello  go wu")
	fmt.Println("hello  go 1")
	fmt.Println("hello  go 1")
}
//结果
/* D:\golang\goproject\src\src01> go run demo32\main.go
hello  go 1
hello  go ming
hello  go wu
hello  go 1
hello  go 1 */

　　return 结束函数体

package main

import "fmt"
func main(){
	for i :=1; i<=100;i++{
		fmt.Println(i)	
		if i == 14 {
			return  // 结束函数体
		}
		
	}
	fmt.Println("gool")
}
/* 结果
D:\golang\goproject\src\src01> go run demo33\main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14 */