yyz notes
YiZhang-You
2023-05-24
目录

流程控制

# 1. 流程控制介绍

# 流程控制的作用

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

# 控制语句的分类

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

  • “顺序结构”代表“先执行a，再执行b”的逻辑。

  • “条件判断结构”代表“如果…，则…”的逻辑。

  • “循环结构”代表“如果…，则再继续…”的逻辑。 三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。 本章是大家真正进入编程界的“门票”。

# 流程控制的流程

# 2. 分支结构

# if else（分支结构）

关键字 if 是用于测试某个条件（布尔型或逻辑型）的语句，如果该条件成立，则会执行 if 后由大括号{}括起来的代码块，否则就忽略该代码块继续执行后续的代码。

# 单分支

# 基本语法
if 条件表达式 {
逻辑代码
}
1
2
3

当条件表达式为ture时，就会执行得的代码。 PS：条件表达式左右的()可以不写，也建议不写 PS：if和表达式中间，一定要有空格 PS：在Golang中，{}是必须有的,就算你只写一行代码。

# 代码示例
package main

import "fmt"

func main() {
	//实现功能：如果口罩的库存小于30个，提示：库存不足：
	//单分支：
	var count int = 3
	if count < 30 {
		fmt.Println("对不起，口罩存量不足")
	}
	//if后面表达式，返回结果一定是true或者false，
	//如果返回结果为true的话，那么{}中的代码就会执行
	//如果返回结果为false的话，那么{}中的代码就不会执行
	//if后面一定要有空格，和条件表达式分隔开来
	//{}一定不能省略
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 双分支

# 基本语法
if 条件表达式 {
   逻辑代码1
} else {
   逻辑代码2
}
当条件表达式成立，即执行逻辑代码1，否则执行逻辑代码2。{}也是必须有的。

PS：下面的格式是错误的：go语言会校验格式
if 条件表达式 {
   逻辑代码1
}
else {
   逻辑代码2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 代码示例
package main

import "fmt"

func main() {
	//实现功能：如果口罩的库存小于30个，提示：库存不足,否则提示：库存充足
	//定义口罩的数量：
	var count int = 70
	if count < 30 { //这个条件表达式返回的是true的话，后面{}执行了
		fmt.Println("库存不足")
	} else { //count >= 30
		fmt.Println("库存充足")
	}
	//双分支一定会二选一走其中一个分支。
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 多分支

# 基本语法
if 条件表达式1 {
    逻辑代码1
} else if 条件表达式2 {
    逻辑代码2
}
.......
else {
                逻辑代码n
}
1
2
3
4
5
6
7
8
9
# 代码示例
package main

import "fmt"

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

	//方式1：利用if单分支实现：
	//定义一个学生的成绩：
	var score int = 18
	//对学生的成绩进行判定：
	// if score >= 90 {
	// 	fmt.Println("您的成绩为A级别")
	// }
	// if score >= 80 && score < 90 {
	// 	fmt.Println("您的成绩为B级别")
	// }
	// if score >= 70 && score < 80 {
	// 	fmt.Println("您的成绩为C级别")
	// }
	// if score >= 60 && score < 70 {
	// 	fmt.Println("您的成绩为D级别")
	// }
	// if score < 60 {
	// 	fmt.Println("您的成绩为E级别")
	// }
	//上面方式1利用多个单分支拼凑出多个选择，多个选择是并列的，依次从上而下顺序执行，即使走了第一个分支，那么其它分支也是需要判断

	//方式2：多分支：优点：如果已经走了一个分支了，那么下面的分支就不会再去判断执行了
	if score >= 90 {
		fmt.Println("您的成绩为A级别")
	} else if score >= 80 { //else隐藏：score < 90
		fmt.Println("您的成绩为B级别")
	} else if score >= 70 { //score < 80
		fmt.Println("您的成绩为C级别")
	} else if score >= 60 { //score < 70
		fmt.Println("您的成绩为D级别")
	} else { //score < 60
		fmt.Println("您的成绩为E级别")
	} //建议你保证else的存在，只有有了else才会真正 起到多选一 的效果
}

/*
	您的成绩为E级别
 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# 特殊写法（简写if else语句）

if 还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断，代码如下：

package main

import "fmt"

// 测试函数
func countTest(count int) (bool, error) {
	if count == 1 {
		return true, nil
	} else {
		return false, nil
	}
}

func main() {
	// 常规写法
	var n1 int = 2
	if n1 > 3 {
		fmt.Println("1")
	} else {
		fmt.Println("2")
	}

	// 简写
	// 示例一：
	if n2 := 20; n2 > 30 {
		fmt.Println("3")
	} else {
		fmt.Println("4")
	}

	// 示例二：! 有问题
	var n3 int = 1
	if _, err := countTest(n3); err != nil {
		fmt.Println("传递参数是1")
	} else {
		fmt.Println("传递参数不是1")
	}
}

/*
	2
	4
	传递参数不是1
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

这种写法可以将返回值与判断放在一行进行处理，而且返回值的作用范围被限制在 if、else 语句组合中。

# switch（分支结构）

Go语言的 switch 要比C语言的更加通用，表达式不需要为常量，甚至不需要为整数，case 按照从上到下的顺序进行求值，直到找到匹配的项，如果 switch 没有表达式，则对 true 进行匹配，因此，可以将 if else-if else 改写成一个 switch。

# 基本语法

switch 表达式 {
  case 值1,值2,.….:
    语句块1
  case 值3,值4,...:
     语句块2
  ....
  default:
   语句块
}
1
2
3
4
5
6
7
8
9

# 基础用法

package main

import "fmt"

func main() {
	//实现功能：根据给出的学生分数，判断学生的等级：
	// >=90  -----A
	// >=80  -----B
	// >=70  -----C
	// >=60  -----D
	// <60   -----E
	//给出一个学生分数：
	var score int = 187
	//根据分数判断等级：
	//switch后面是一个表达式，这个表达式的结果依次跟case进行比较，满足结果的话就执行冒号后面的代码。
	//default是用来“兜底”的一个分支，其它case分支都不走的情况下就会走default分支
	//default分支可以放在任意位置上，不一定非要放在最后。
	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:
		fmt.Println("您的等级为E级")
	case 4:
		fmt.Println("您的等级为E级")
	case 3:
		fmt.Println("您的等级为E级")
	case 2:
		fmt.Println("您的等级为E级")
	case 1:
		fmt.Println("您的等级为E级")
	case 0:
		fmt.Println("您的等级为E级")
	default:
		fmt.Println("您的成绩有误")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# 更多注意事项

（1）switch后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)
（2）case后面的值如果是常量值(字面量)，则要求不能重复
（3）case后的各个值的数据类型，必须和 switch 的表达式数据类型一致
（4）case后面可以带多个值，使用逗号间隔。比如 case 值1,值2...
（5）case后面不需要带break
（6）default语句不是必须的，位置也是随意的。
（7）switch后也可以不带表达式，当做if分支来使用
（8）switch后也可以直接声明/定义一个变量，分号结束，不推荐
1
2
3
4
5
6
7
8

# 代码示例

package main

import "fmt"

func main() {
	/*
		（1）switch后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)
		（2）case后面的值如果是常量值(字面量)，则要求不能重复
		（3）case后的各个值的数据类型，必须和 switch 的表达式数据类型一致
		（4）case后面可以带多个值，使用逗号间隔。比如 case 值1,值2...
		（5）case后面不需要带break
		（6）default语句不是必须的，位置也是随意的。
		（7）switch后也可以不带表达式，当做if分支来使用
		（8）switch后也可以直接声明/定义一个变量，分号结束，不推荐
	*/

	// （1）switch后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)
	switch 10 {
	case 10:
		fmt.Println("您的等级为A级")
	case 9:
		fmt.Println("您的等级为A级")
	default:
		fmt.Println("您的成绩有误")
	}

	//（2）case后面的值如果是常量值(字面量)，则要求不能重复
	switch 10 {
	case 10:
		fmt.Println("您的等级为A级")
	//case 10:
	//	fmt.Println("您的等级为A级") // duplicate case 10 (constant of type int) in expression switch
	case 9:
		fmt.Println("您的等级为A级")
	default:
		fmt.Println("您的成绩有误")
	}

	// （3）case后的各个值的数据类型，必须和 switch 的表达式数据类型一致
	var n1 int8 = 9
	switch 10 {
	case 10:
		fmt.Println("您的等级为A级")
	//case n1:  // invalid case n1 in switch on 10 (mismatched types int8 and int) 数据类型不一致
	//	fmt.Println("您的等级为A级")
	default:
		fmt.Println("您的成绩有误", n1)
	}

	// （4）case后面可以带多个值，使用逗号间隔。比如 case 值1,值2...
	switch 8 {
	case 10, 9, 8, 7:
		fmt.Println("您的等级为A级")
	case 6:
		fmt.Println("您的等级为B级")
	default:
		fmt.Println("您的成绩有误")
	}

	// （5）case后面不需要带break go省略了break

	// （6）default语句不是必须的，位置也是随意的。

	//（7）switch后也可以不带表达式，当做if分支来使用
	n2 := 10
	switch {
	case n2 == 10:
		fmt.Println("您的等级为A级")
	case n2 == 8:
		fmt.Println("您的等级为B级")
	default:
		fmt.Println("您的成绩有误")
	}

	// （8）switch后也可以直接声明/定义一个变量，分号结束，不推荐
	switch n3 := 10; {
	case n3 > 9:
		fmt.Println("您的等级为A级")
	case n3 == 8:
		fmt.Println("您的等级为B级")
	default:
		fmt.Println("您的成绩有误")
	}
}

/*
	您的等级为A级
	您的等级为A级
	您的等级为A级
	您的等级为A级
	您的等级为A级
	您的等级为A级
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

# switch穿透fallthrough

在case语句块后增加fallthrough ,则会继续执行下一个case,也叫switch穿透（只会执行下面一个的case,后面没有case的话不执行）

package main

import "fmt"

func main() {
	var score int = 100
	switch score / 10 {
	case 10:
		fmt.Println("您的等级为A级")
		fallthrough // 在case语句块后增加fallthrough ,则会继续执行下一个case,也叫switch穿透（只会执行下面的一个,后面没有case的话不执行）
	case 9:
		fmt.Println("您的等级为B级")
	case 8:
		fmt.Println("您的等级为C级")
	default:
		fmt.Println("您的成绩有误")
	}

}

/*
	您的等级为C级
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 2. 循环结构

# for（循环结构）

Go语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构，关键字 for 的基本使用方法与C语言和 C++ (opens new window)中非常接近

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

  • 初始化部分设置循环变量的初值

  • 条件判断部分为任意布尔表达式

  • 迭代因子控制循环变量的增减

for循环在执行条件判定后，先执行的循环体部分，再执行步进。 for循环结构的流程图如图所示：

# 基本语法

for 初始表达式; 布尔表达式; 迭代因子 {
          循环体;
}
1
2
3

# 基础用法

  • for的初始表达式 不能用var定义变量的形式，要用:=

  • for循环实际就是让程序员写代码的效率高了，但是底层该怎么执行还是怎么执行的，底层效率没有提高，只是程序员写代码简洁了而已

# 常规格式

package main

import "fmt"

func main() {
	//实现一个功能：求和： 1+2+3+4+5：
	//求和：
	//利用for循环来解决问题：
	var sum int = 0
	for i := 1; i <= 5; i++ {
		sum += i
	}

	//输出结果：
	fmt.Println(sum)
	// for循环的语法格式：
	// for 初始表达式; 布尔表达式（条件判断）; 迭代因子 {
	// 	循环体;--》反复重复执行的内容
	// }
	// 注意：for的初始表达式 不能用var定义变量的形式，要用:=
	// 注意：for循环实际就是让程序员写代码的效率高了，但是底层该怎么执行还是怎么执行的，底层效率没有提高，只是程序员写代码简洁了而已
}

/*
	15
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 简洁格式

// 简介格式
	n1 := 0  // 初始值
	for n1 <= 5 {
		fmt.Println(n1)
		n1++
	}
1
2
3
4
5
6

# 死循环

package main

import "fmt"

func main() {
	//死循环：
	
	// for {
	// 	fmt.Println("你好 Golang")
	// }
	
	for ;; {
		fmt.Println("你好 Golang")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# for range（键值循环）

for range 结构是Go语言特有的一种的迭代结构，在许多情况下都非常有用，for range 可以遍历数组、切片、字符串、map 及通道（channel），for range 语法上类似于其它语言中的 foreach 语句

通过 for range 遍历的返回值有一定的规律：

  • 数组、切片、字符串返回索引和值。

  • map 返回键和值。

  • 通道（channel）只返回通道内的值

# 基础语法

for key, val := range coll {
    ...
}

key 下标
val 值
1
2
3
4
5
6

# 基本使用

# 遍历字符串

Go语言和其他语言类似，可以通过 for range 的组合，对字符串进行遍历，遍历时，key 和 value 分别代表字符串的索引和字符串中的每一个字符。

package main

import "fmt"

func main() {
	//定义一个字符串：
	var str string = "hello golang你好"
	//方式1：普通for循环：按照字节进行遍历输出的 （暂时先不使用中文），直接使用for遍历中文会出现问题因为一个中文占用三个字节
	for i := 0; i < len(str); i++ { //i:理解为字符串的下标
		fmt.Printf("%c \n", str[i])
	}

	//方式2：for range
	for i, value := range str {
		fmt.Printf("索引为：%d,具体的值为：%c \n", i, value)
	}
	//对str进行遍历，遍历的每个结果的索引值被i接收，每个结果的具体数值被value接收
	//遍历对字符进行遍历的
}

/*
	h
	e
	l
	l
	o
	
	g
	o
	l
	a
	n
	g
	ä
	½
	 
	å
	¥
	½
	索引为：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,具体的值为：好
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
编辑 (opens new window)
输入输出
break（跳出循环）

← break（跳出循环）→

最近更新
01
配置yun源
05-24
02
linux-配置python虚拟环境
05-24
03
linux文件目录管理
05-24
更多文章>
Theme by Vdoing | Copyright © 2023-2023 yizhang | MIT License