流程控制
文章发布较早,内容可能过时,阅读注意甄别。
Go 语言支持最基本的三种程序运算结构:顺序结构,选择结构,循环结构。
- 顺序结构:程序按顺序执行,不发生跳转。
- 选择结构:依据是否满足条件,有选择的执行符合条件的程序。
- 循环结构:依据条件是否满足,循环多次执行某段代码。
# 1,if 判断。
# 1,if 简单使用。
package main
import "fmt"
func main() {
s := "王思聪"
//if和{就是条件,条件通常都是关系运算符
if s == "王思聪" { //左括号和if要在同一行
fmt.Println("左右一个妹子,右手一个大妈")
}
//if支持嵌入1个初始化语句,初始化语句和判断条件以分号分隔
if a := 10; a == 10 { //条件为真,则执行如下打印语句
fmt.Println("a = 10")
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 2,if 复杂判断。
package main
import "fmt"
func main() {
//1
a := 10
if a == 10 {
fmt.Println("a = 10")
} else {
fmt.Println("a != 10")
}
//2
if a := 9; a == 10 {
fmt.Println("a = 10")
} else {
fmt.Println("a != 10")
}
//注意,上边虽然两个例子里边都使用了变量a,但是并不会报冲突。
//3
b := 8
if a == 10 {
fmt.Println("b = 10")
} else if b < 10 {
fmt.Println("b < 10")
} else if b > 10 {
fmt.Println("b > 10")
} else {
fmt.Println("这是不可能的!")
}
//4
if b := 8; b == 10 {
fmt.Println("b = 10")
} else if b < 10 {
fmt.Println("b < 10")
} else if b > 10 {
fmt.Println("b > 10")
} else {
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
45
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
# 2,switch 语句。
switch 语句与 shell 当中的 case 语句非常类似,只不过语法关键字稍微不同。
package main
import "fmt"
func main() {
num := 1
switch num { //switch后面写的是变量本身
case 1:
fmt.Printf("选择的楼层是%d层", num)
break //go语言也有break关键字,表示跳出switch语句,可以不写,默认就包含
fallthrough //表示不跳出switch语句,后面的无条件执行,不常用,了解即可
case 2:
fmt.Printf("选择的楼层是%d层", num)
//break
case 3:
fmt.Printf("选择的楼层是%d层", num)
//break
case 4:
fmt.Printf("选择的楼层是%d层", num)
//break
case 5:
fmt.Printf("选择的楼层是%d层", num)
//break
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
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
switch 的一些其他用法介绍。
package main
import "fmt"
func main() {
//switch也支持直接初始化语句,初始化语句和变量本身以分号分隔
switch num := 4; num {
case 1:
fmt.Printf("选择的楼层是%d层", num)
case 2:
fmt.Printf("选择的楼层是%d层", num)
case 3, 4, 5: //如果有多个条件结果一样,那么多条件可以写在一起
fmt.Println("选择的是xx层")
case 6:
fmt.Printf("选择的楼层是%d层", num)
default: //用于匹配条件以外的情况
fmt.Println("您选择的楼层不存在!")
}
//还可以将条件写在case语句当中,示例如下:
score := 85
switch {
case score >= 90:
fmt.Println("优秀")
case score >= 80:
fmt.Println("良好")
case score >= 70:
fmt.Println("一般")
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
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
# 3,for 循环。
package main
import "fmt"
func main() {
/*标准格式如下:
for 初始条件; 判断条件; 条件变化 {
}
*/
//算出1+2+3...100的累加和
sum := 0
/*
1,初始条件 i := 1
2,判断条件 i <= 100 是否为真,如果为真,则执行循环体,如果为假,则跳出
3,条件变化 i++
4,重复 第2,3,4步
*/
for i := 1; i <= 100; i++ {
sum = sum + i
}
fmt.Println("sum =", sum)
}
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 4,range 关键字。
package main
import "fmt"
func main() {
str := "abc"
//通过for打印每个字符
for i := 0; i < len(str); i++ {
fmt.Printf("str[%d]=%c\n", i, str[i])
}
//range表示迭代打印每个元素,默认返回2个值:一个是元素的位置,一个是元素的值
for i, data := range str { //i表示的是元素的位置(0,1,2),data表示的是元素对应的值(a,b,c)
fmt.Printf("str[%d]=%c\n", i, data)
}
//等价于如下写法:
for i := range str { //第2个返回值,默认丢弃,返回元素的位置(下标)
fmt.Printf("str[%d]=%c\n", i, str[i])
}
//又等价于如下写法
for i, _ := range str {
fmt.Printf("str[%d]=%c\n", i, str[i])
}
}
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
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
# 5,break 和 continue。
break 表示跳出当前循环。 continue 表示跳出本次循环。
注意:break 可以用于 for,switch,select,而 continue 只能用在 for 循环当中。
package main
import (
"fmt"
"time"
)
func main() {
i := 0
for { //for后边不写任何东西,表示这个循环条件永远为真,即死循环,或者无限循环
i++
time.Sleep(time.Second) //表示sleep 1 s
if i == 5 {
//break //跳出循环,如果嵌套多个循环,则跳出最近的那个内循环
continue //跳出本次循环
}
fmt.Println("i =", i)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 6,goto 关键字。
package main
import (
"fmt"
)
func main() {
//注释掉上边的fmt包,可以单独测试如下两个关键字
//break //输出:break is not in a loop, switch, or select
//continue //输出:continue is not in a loop
//goto可以用在任何地方,但是不能够跨函数使用
fmt.Println("1111111")
goto End //goto是关键词,End是自定义的标签
fmt.Println("2222222")
End:
fmt.Println("3333333")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
但是日常写代码不建议使用这个关键字,会显得代码比较乱。
上次更新: 2024/06/13, 22:13:45