流程控制

流程控制是每种编程语言控制逻辑走向和执行次序的重要部分，流程控制可以说是一门语言的“经脉”。

Go语言中最常用的流程控制有if和for，而switch和goto主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。

1. if_else（分支结构）

1.1 基本写法

Go语言中if条件判断的格式如下：

注意：在go语言中布尔表达式不用使用括号！！！

if 布尔表达式1 {
    分支1
} else if 布尔表达式2 {
    分支2
} else{
    分支3
}
1
2
3
4
5
6
7

实例：

func ifDemo1() {
	score := 65
	if score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}
1
2
3
4
5
6
7
8
9
10

1.2 特殊写法

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

func ifDemo2() {
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}
1
2
3
4
5
6
7
8
9

注意点：

1. 布尔表达式不需使用括号{}将条件包含起来。
2. 大括号{}必须存在，即使只有一行语句
3. 左括号必须在if或else的同一行
4. 在if之后，条件语句之前，可以添加变量初始化语句，使用；进行分隔，其作用域仅限条件语句。

2. for（循环结构）

Go 语言中的所有循环类型均可以使用for关键字来完成。

2.1 基本写法

for循环的基本格式如下：

注意：for表达式不用加括号！！！

for 初始语句;条件表达式;结束语句{
    循环体语句
}
1
2
3

实例：

# 循环输出1到10
func f() {
	for i := 1; i <= 10; i++ {
		fmt.Printf("i: %v\n", i)
	}
}
1
2
3
4
5
6

初始条件，可以写到外面，但分号必须保留。

func f() {
	i := 1
	for ; i <= 10; i++ {
		fmt.Printf("i: %v\n", i)
	}
}
1
2
3
4
5
6

初始条件和结束条件都可以省略

func f() {
	i := 1 // 初始条件
	for i <= 10 {
		fmt.Printf("i: %v\n", i)
		i++ // 结束条件
	}
}
1
2
3
4
5
6
7

2.2 特殊写法

无限循环

func f() {
	for {
		fmt.Println("我一直在执行~")
	}
}

func main() {
	f()
}
1
2
3
4
5
6
7
8
9

for循环可以通过break、goto、return、panic语句强制退出循环。

3. for range（键值循环）

Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。 通过for range遍历的返回值有以下规律：

1. 数组、切片、字符串返回索引和值。
2. map返回键和值。
3. 通道（channel）只返回通道内的值。

3.1 基本写法

快捷生成代码：forr

for key, value := range coll {
    ...
}
1
2
3

3.2 实例

循环数组

// i代表索引，v代表数组中的值
func f5() {
	a := [...]int{1, 2, 3, 4, 5}
	for i, v := range a {
		fmt.Printf("i: %d, v: %v\n", i, v)
	}
}

func main() {
	f5()
}
1
2
3
4
5
6
7
8
9
10
11

运行结果

i: 0, v: 1
i: 1, v: 2
i: 2, v: 3
i: 3, v: 4
i: 4, v: 5
1
2
3
4
5

循环字符串

func f6() {
	s := "咸蛋黄派是大帅哥"
	for i, v := range s {
		fmt.Printf("i: %d, v: %c\n", i, v)
	}
	// %c 按照字符输出
}

func main() {
	f6()
}
1
2
3
4
5
6
7
8
9
10
11

运行结果

i: 0, v: 咸
i: 3, v: 蛋
i: 6, v: 黄
i: 9, v: 派
i: 12, v: 是
i: 15, v: 大
i: 18, v: 帅
i: 21, v: 哥
1
2
3
4
5
6
7
8

循环切片

func f7() {
	s := []int{1, 2, 3, 4, 5}
	for i, v := range s {
		fmt.Printf("i: %d, v: %v\n", i, v)
	}
}

func main() {
	f7()
}
1
2
3
4
5
6
7
8
9
10

循环map

func f8() {
	m := make(map[string]string)
	m["name"] = "咸蛋黄派"
	m["age"] = "18"
	m["company"] = "huanle"
	for _, v := range m {
		fmt.Printf("v: %v\n", v)
	}
	// _,表示省略给索引定义，在go里面，如果定义了就必须引用，否则会报错
}

func main() {
	f8()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果

v: 18
v: huanle
v: 咸蛋黄派
1
2
3

4. switch case

go语言中的switch语句，可以非常容易的判断多个值的情况。

4.1 基本写法

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}
1
2
3
4
5
6
7
8

4.2 实例

判断成绩

func f() {
	grade := "A"
	switch grade {
	case "A":
		fmt.Println("优秀")
	case "B":
		fmt.Println("良好")
	default:
		fmt.Println("一般")
	}
}
1
2
3
4
5
6
7
8
9
10
11

运行结果

优秀
1

case一次判断多个值

go语言switch语句，可以同时匹配多个条件，中间用逗号分隔，有其中一个匹配成功即可。

func f() {
	day := 3
	switch day {
	case 1, 2, 3, 4, 5:
		fmt.Println("工作日")
	case 6, 7:
		fmt.Println("休息日")
	}
}
1
2
3
4
5
6
7
8
9

运行结果

工作日
1

case可以是条件表达式

func f() {
	score := 90
	switch {
	case score >= 90:
		fmt.Println("享受假期")
	case score < 90 && score >= 80:
		fmt.Println("好好学习吧！")
	default:
		fmt.Println("玩命学习！")
	}
}
1
2
3
4
5
6
7
8
9
10
11

运行结果

享受假期
1

fallthrough可以执行满足条件的下一个case

func f3() {
	a := 100
	switch a {
	case 100:
		fmt.Println("100")
		fallthrough
	case 200:
		fmt.Println("200")
	case 300:
		fmt.Println("300")
	default:
		fmt.Println("other")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果

100
200
1
2

go语言中switch语句的注意事项

1. 支持多条件匹配
2. 不同的 case 之间不使用 break 分隔，默认只会执行一个 case。
3. 如果想要执行多个 case，需要使用 fallthrough 关键字，也可用 break 终止。
4. 分支还可以使用表达式，例如：a>10.

5. goto（跳转到指定标签）

goto语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时：

func gotoDemo1() {
	var breakFlag bool
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				breakFlag = true
				break
			}
			fmt.Printf("%v-%v\n", i, j)
		}
		// 外层for循环判断
		if breakFlag {
			break
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

使用goto语句能简化代码：

func gotoDemo2() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
breakTag:
	fmt.Println("结束for循环")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6. 关键字

6.1 break(跳出循环)

break语句可以结束for、switch和select的代码块。

break语句还可以在语句后面添加标签，表示退出某个标签对应的代码块，标签要求必须定义在对应的for、switch和 select的代码块上。 举个例子：

func breakDemo1() {
BREAKDEMO1:
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break BREAKDEMO1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	fmt.Println("...")
}
1
2
3
4
5
6
7
8
9
10
11
12

6.2 continue(继续下次循环)

continue语句可以结束当前循环，开始下一次的循环迭代过程，仅限在for循环内使用。

在 continue语句后添加标签时，表示开始标签对应的循环。例如：

func continueDemo() {
forloop1:
	for i := 0; i < 5; i++ {
		// forloop2:
		for j := 0; j < 5; j++ {
			if i == 2 && j == 2 {
				continue forloop1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12