控制结构

if 的“快乐路径”原则

针对程序的分支结构，Go 提供了 if 和 switch-case 两种语句形式；而针对循环结构，Go 只保留了 for 这一种循环语句形式。

if 语句

if 语句是 Go 语言中提供的一种分支控制结构，它也是 Go 中最常用、最简单的分支控制结构。它会根据布尔表达式的值，在两个分支中选择一个执行。
虽然各种编程语言几乎都原生支持了 if 语句，但 Go 的 if 语句依然有着自己的特点：
- 第一，和 Go 函数一样，if 语句的分支代码块的左大括号与 if 关键字在同一行上，这也是 Go 代码风格的统一要求，gofmt 工具会帮助我们实现这一点；
- 第二，if 语句的布尔表达式整体不需要用括号包裹，一定程度上减少了开发人员敲击键盘的次数。而且，if 关键字后面的条件判断表达式的求值结果必须是布尔类型，即要么是 true，要么是 false。
- 如果判断的条件比较多，我们可以用多个逻辑操作符连接起多个条件判断表达式，比如这段代码就是用了多个逻辑操作符 && 来连接多个布尔表达式：
```
if (runtime.GOOS == "linux") && (runtime.GOARCH == "amd64") &&
(runtime.Compiler != "gccgo") {
	println("we are using standard go compiler on linux os for amd64")
}
```
Go 语言的 if 语句还有其他多种形式，比如二分支结构和多（N）分支结构。多分支结构引入了 else if。

支持声明 if 语句的自用变量

无论是单分支、二分支还是多分支结构，我们都可以在 if 后的布尔表达式前，进行一些变量的声明，在 if 布尔表达式前声明的变量，称为 if 语句的自用变量。顾名思义，这些变量只可以在 if 语句的代码块范围内使用。
在 if 语句中声明自用变量是 Go 语言的一个惯用法，这种使用方式直观上可以让开发者有一种代码行数减少的感觉，提高可读性。同时，由于这些变量是 if 语句自用变量，它的作用域仅限于 if 语句的各层隐式代码块中，if 语句外部无法访问和更改这些变量，这就让这些变量具有一定隔离性，这样你在阅读和理解 if 语句的代码时也可以更聚焦。

if 语句的“快乐路径”原则

从可读性上来看，单分支结构要优于二分支结构，二分支结构又优于多分支结构。那么显然，我们在日常编码中要减少多分支结构，甚至是二分支结构的使用，这会有助于我们编写出优雅、简洁、易读易维护且不易错的代码。
if 语句的“快乐路径（Happy Path）”原则
- 仅使用单分支控制结构；
- 当布尔表达式求值为 false 时，也就是出现错误时，在单分支中快速返回；
- 正常逻辑在代码布局上始终“靠左”，这样读者可以从上到下一眼看到该函数正常逻辑的全貌；
- 函数执行到最后一行代表一种成功状态。

Go 中的 switch 语句

认识 switch 语句

除了 if 语句之外，Go 语言还提供了一种更适合多路分支执行的分支控制结构，也就是 switch 语句。
在一些执行分支较多的场景下，使用 switch 分支控制语句可以让代码更简洁，可读性更好。
Go 语言中 switch 语句的一般形式：
```
switch initStmt; expr {
	case expr1:
	// 执行分支1
	case expr2:
	// 执行分支2
	case expr3_1, expr3_2, expr3_3:
	// 执行分支3
	case expr4:
	// 执行分支4
	... ...
	case exprN:
	// 执行分支N
	default:
	// 执行默认分支
}
```
- 首先看这个 switch 语句一般形式中的第一行，这一行由 switch 关键字开始，它的后面通常接着一个表达式（expr），这句中的 initStmt 是一个可选的组成部分。
- 我们可以在 initStmt 中通过短变量声明定义一些在 switch 语句中使用的临时变量。
- 接下来，switch 后面的大括号内是一个个代码执行分支，每个分支以 case 关键字开始，每个 case 后面是一个表达式或是一个逗号分隔的表达式列表。
- 这里还有一个以 default 关键字开始的特殊分支，被称为默认分支。
- 最后，我们再来看 switch 语句的执行流程。switch 语句会用 expr 的求值结果与各个 case 中的表达式结果进行比较，如果发现匹配的 case，也就是 case 后面的表达式，或者表达式列表中任意一个表达式的求值结果与 expr 的求值结果相同，那么就会执行该 case 对应的代码分支，分支执行后，switch 语句也就结束了。
- 如果所有 case 表达式都无法与 expr 匹配，那么程序就会执行 default 默认分支，并且结束 switch 语句。
- Go 先对 switch expr 表达式进行求值，然后再按 case 语句的出现顺序，从上到下进行逐一求值。在带有表达式列表的 case 语句中，Go 会从左到右，对列表中的表达式进行求值。

switch 语句的灵活性

C 语言中的 switch 语句对表达式类型有限制，每个 case 语句只可以有一个表达式。而且，除非你显式使用 break 跳出，程序默认总是执行下一个 case 语句。这些特性开发人员带来了使用上的心智负担。
相较于 C 语言中 switch 语句的“死板”，Go 的 switch 语句表现出极大的灵活性，主要表现在如下几方面：
- 首先，switch 语句各表达式的求值结果可以为各种类型值，只要它的类型支持比较操作就可以了。
  - C 语言中，switch 语句中使用的所有表达式的求值结果只能是 int 或枚举类型，其他类型都会被 C 编译器拒绝。
  - Go 语言就宽容得多了，只要类型支持比较操作，都可以作为 switch 语句中的表达式类型。比如整型、布尔类型、字符串类型、复数类型、元素类型都是可比较类型的数组类型，甚至字段类型都是可比较类型的结构体类型，也可以。
```
type person struct {
	name string
	age int
} 
func main() {
	p := person{"tom", 13}
	switch p {
	case person{"tony", 33}:
		println("match tony")
	case person{"tom", 13}:
		println("match tom")
	case person{"lucy", 23}:
		println("match lucy")
	default:
		println("no match")
	}
}
```
- 第二点：switch 语句支持声明临时变量。
- 第三点：case 语句支持表达式列表。
- 第四点：取消了默认执行下一个 case 代码逻辑的语义。

type switch

"type switch”这是一种特殊的 switch 语句用法：
```
func main() {
	var x interface{} = 13
	switch x.(type) {
	case nil:
		println("x is nil")
	case int:
		println("the type of x is int")
	case string:
		println("the type of x is string")
	case bool:
		println("the type of x is string")
	default:
		println("don't support the type")
	}
}
```
- switch 关键字后面跟着的表达式为 x.(type)，这种表达式形式是 switch 语句专有的，而且也只能在 switch 语句中使用。这个表达式中的 x 必须是一个接口类型变量，表达式的求值结果是这个接口类型变量对应的动态类型。
- 接着，case 关键字后面接的就不是普通意义上的表达式了，而是一个个具体的类型。这样，Go 就能使用变量 x 的动态类型与各个 case 中的类型进行匹配，之后的逻辑就都是一样的了。
Go 语言规范中明确规定，不带 label 的 break 语句中断执行并跳出的，是同一函数内 break 语句所在的最内层的 for、switch 或 select。

Go 的 for 循环

for 语句的经典使用形式

主流编程语言都提供了对循环结构的支持，绝大多数主流语言，包括 C 语言、C++、Java 和 Rust，甚至连动态语言 Python 还提供了不止一种的循环语句，但 Go 却只有一种，也就是 for 语句。

Go 语言中 for 循环语句的经典形式：

var sum int
for i := 0; i < 10; i++ {
	sum += i
}
println(sum)

在这里插入图片描述

图中①对应的组成部分执行于循环体（③ ）之前，并且在整个 for 循环语句中仅会被执行一次，它也被称为循环前置语句。
- 我们通常会在这个部分声明一些循环体（③ ）或循环控制条件（② ）会用到的自用变量，也称循环变量或迭代变量，比如这里声明的整型变量 i。
- 与 if 语句中的自用变量一样，for 循环变量也采用短变量声明的形式，循环变量的作用域仅限于 for 语句隐式代码块范围内。
图中②对应的组成部分，是用来决定循环是否要继续进行下去的条件判断表达式。
- 和 if 语句的一样，这个用于条件判断的表达式必须为布尔表达式，如果有多个判断条件，我们一样可以由逻辑操作符进行连接。
- 当表达式的求值结果为 true 时，代码将进入循环体（③）继续执行，相反则循环直接结束，循环体（③）与组成部分④都不会被执行。
图中③对应的组成部分是 for 循环语句的循环体。
- 如果相关的判断条件表达式求值结构为 true 时，循环体就会被执行一次，这样的一次执行也被称为一次迭代（Iteration）。
- 在上面例子中，循环体执行的动作是将这次迭代中变量 i 的值累加到变量 sum 中。
图中④对应的组成部分会在每次循环体迭代之后执行，也被称为循环后置语句。
- 这个部分通常用于更新 for 循环语句组成部分①中声明的循环变量，比如在这个例子中，我们在这个组成部分对循环变量 i 进行加 1 操作。
Go 语言的 for 循环支持声明多循环变量，并且可以应用在循环体以及判断条件中：
```
for i, j, k := 0, 1, 2; (i < 20) && (j < 10) && (k < 30); i, j, k = i+1, j+1,
	sum += (i + j + k)
	println(sum)
}
```
- 除了循环体部分之外，其余的三个部分都是可选的。
- 虽然对前置语句或后置语句进行了省略，但经典 for 循环形式中的分号依然被保留着，这是 Go 语法的要求。
- 当循环前置与后置语句都省略掉，仅保留循环判断条件表达式时，我们可以省略经典 for 循环形式中的分号。
- 当 for 循环语句的循环判断条件表达式的求值结果始终为 true 时，我们就可以将它省略掉了。这个 for 循环就是我们通常所说的“无限循环”。

for range 循环形式

针对像切片这样的复合数据类型，还有 Go 原生的字符串类型（string），Go 语言提供了一个更方便的“语法糖”形式：for range。
```
var sl = []int{1, 2, 3, 4, 5}
for i, v := range sl {
	fmt.Printf("sl[%d] = %d\n", i, v)
}
```
- for range 循环形式与 for 语句经典形式差异较大，除了循环体保留了下来，其余组成部分都“不见”了。其实那几部分已经被融合到 for range 的语义中了。
- 这里的 i 和 v 对应的是经典 for 语句形式中循环前置语句的循环变量，它们的初值分别为切片 sl 的第一个元素的下标值和元素值。
- 隐含在 for range 语义中的循环控制条件判断为：是否已经遍历完 sl 的所有元素，等价于i < len(sl)这个布尔表达式。
- 每次迭代后，for range 会取出切片 sl 的下一个元素的下标和值，分别赋值给循环变量 i 和 v，这与 for 经典形式下的循环后置语句执行的逻辑是相同的。
for range 语句也有几个常见“变种”：
- 变种一：当我们不关心元素的值时，我们可以省略代表元素值的变量 v，只声明代表下标值的变量 i。
- 变种二：如果我们不关心元素下标，只关心元素值，那么我们可以用空标识符替代代表下标值的变量 i。这里一定要注意，这个空标识符不能省略，否则就与上面的“变种一”形式一样了，Go 编译器将无法区分。
- 变种三：如果我们既不关心下标值，也不关心元素值，可以将 i，v 都省略。

string 类型

for range 对于 string 类型来说，每次循环得到的 v 值是一个 Unicode 字符码点，也就是 rune 类型值，而不是一个字节，返回的第一个值 i 为该 Unicode 字符码点的内存编码（UTF-8）的第一个字节在字符串内存序列中的位置。
使用 for 经典形式与使用 for range 形式，对 string 类型进行循环操作的语义是不同的。

map

map 就是一个键值对（key-value）集合，最常见的对 map 的操作，就是通过 key 获取其对应的 value 值。但有些时候，我们也要对 map 这个集合进行遍历，这就需要 for 语句的支持了。
但在 Go 语言中，我们要对 map 进行循环操作，for range 是唯一的方法，for 经典循环形式是不支持对 map 类型变量的循环控制的。
for range 对于 map 类型来说，每次循环，循环变量 k 和 v 分别会被赋值为 map 键值对集合中一个元素的 key 值和 value 值。

channel

channel 是 Go 语言提供的并发设计的原语，它用于多个 Goroutine 之间的通信。
当 channel 类型变量作为 for range 语句的迭代对象时，for range 会尝试从 channel 中读取数据，使用形式是这样的：
```
var c = make(chan int)
for v := range c {
	// ...
}
```
- for range 每次从 channel 中读取一个元素后，会把它赋值给循环变量 v，并进入循环体。当 channel 中没有数据可读的时候，for range 循环会阻塞在对 channel 的读操作上。
- 直到 channel 关闭时，for range 循环才会结束，这也是 for range 循环与 channel 配合时隐含的循环判断条件。

带 label 的 continue 语句

日常开发中，出于算法逻辑的需要，我们可能会有中断当前循环体并继续下一次迭代的时候，也会有中断循环体并彻底结束循环语句的时候。针对这些情况，Go 语言提供了 continue 语句和 break 语句。
- 如果循环体中的代码执行到一半，要中断当前迭代，忽略此迭代循环体中的后续代码，并回到 for 循环条件判断，尝试开启下一次迭代，这个时候我们可以使用 continue 语句来应对。
- Go 语言中的 continue 在 C 语言 continue 语义的基础上又增加了对 label 的支持。
  - label 语句的作用，是标记跳转的目标。
```
func main() {
	var sum int
	var sl = []int{1, 2, 3, 4, 5, 6}
loop:
	for i := 0; i < len(sl); i++ {
		if sl[i]%2 == 0 {
		// 忽略切片中值为偶数的元素
		continue loop
	}
		sum += sl[i]
	}
	println(sum) // 9
}
```
  - 在这段代码中，我们定义了一个 label：loop，它标记的跳转目标恰恰就是我们的 for 循环。也就是说，我们在循环体中可以使用 continue+ loop label 的方式来实现循环体中断。
  - 通常我们在这样非嵌套循环的场景中会直接使用不带 label 的 continue 语句。
  - 带 label 的 continue 语句，通常出现于嵌套循环语句中，被用于跳转到外层循环并继续执行外层循环语句的下一个迭代：
```
func main() {
	var sl = [][]int{
		{1, 34, 26, 35, 78},
		{3, 45, 13, 24, 99},
		{101, 13, 38, 7, 127},
		{54, 27, 40, 83, 81},
	}
outerloop:
	for i := 0; i < len(sl); i++ {
		for j := 0; j < len(sl[i]); j++ {
			if sl[i][j] == 13 {
				fmt.Printf("found 13 at [%d, %d]\n", i, j)
				continue outerloop
			}
		}
	}
}
```

break 语句的使用

无论带不带 label，continue 语句的本质都是继续循环语句的执行。但日常编码中，我们还会遇到一些场景，在这些场景中，我们不仅要中断当前循环体迭代的进行，还要同时彻底跳出循环，终结整个循环语句的执行。面对这样的场景，continue 语句就不再适用了，Go 语言为我们提供了 break 语句来解决这个问题。
和 continue 语句一样，Go 也 break 语句增加了对 label 的支持。而且，和 continue 语句一样，如果遇到嵌套循环，break 要想跳出外层循环，用不带 label 的 break 是不够，因为不带 label 的 break 仅能跳出其所在的最内层循环。要想实现外层循环的跳出，我们还需给 break 加上 label。

for 语句的常见“坑”与避坑方法

问题一：循环变量的重用
- for range 形式的循环语句，使用短变量声明的方式来声明循环变量，循环体将使用这些循环变量实现特定的逻辑，但在使用的时候，可能会发现循环变量的值与“预期”不符。
- 有时候循环变量在 for range 语句中仅会被声明一次，且在每次迭代中都会被重用。
问题二：参与循环的是 range 表达式的副本
- 在 for range 语句中，range 后面接受的表达式的类型可以是数组、指向数组的指针、切片、字符串，还有 map 和 channel（需具有读权限）。
```
func main() {
	var a = [5]int{1, 2, 3, 4, 5}
	var r [5]int
	fmt.Println("original a =", a)
	for i, v := range a {
	  if i == 0 {
		a[1] = 12
		a[2] = 13
	  }
	  r[i] = v
	} 
	fmt.Println("after for range loop, r =", r)
	fmt.Println("after for range loop, a =", a)
}
```
  - 每次迭代的都是从数组 a 的值拷贝 a’ 中得到的元素。
  - a’是 Go 临时分配的连续字节序列，与 a 完全不是一块内存区域。
  - 因此无论 a 被如何修改，它参与循环的副本 a’依旧保持原值，因此 v 从 a’中取出的仍旧是 a 的原值，而不是修改后的值。
- 那么应该如何解决这个问题，让输出结果符合我们的预期呢？
  - 大多数应用数组的场景我们都可以用切片替代：
```
func main() {
	var a = [5]int{1, 2, 3, 4, 5}
	var r [5]int
	fmt.Println("original a =", a)
	for i, v := range a[:] {
		if i == 0 {
			a[1] = 12
			a[2] = 13
		}
		r[i] = v
	} 
	fmt.Println("after for range loop, r =", r)
	fmt.Println("after for range loop, a =", a)
}
```
  - 在 range 表达式中，我们用了 a[:]替代了原先的 a，也就是将数组 a 转换为一个切片，作为 range 表达式的循环对象。
  - 当进行 range 表达式复制时，我们实际上复制的是一个切片，也就是表示切片的结构体。表示切片副本的结构体中的 array，依旧指向原切片对应的底层数组，所以我们对切片副本的修改也都会反映到底层数组 a 上去。
  - 而 v 再从切片副本结构体中 array 指向的底层数组中，获取数组元素，也就得到了被修改后的元素值。
问题三：遍历 map 中元素的随机性
- 如果我们在循环的过程中，对 map 进行了修改，那么这样修改的结果是否会影响后续迭代呢？这个结果和我们遍历 map 一样，具有随机性。
- 我们日常编码遇到遍历 map 的同时，还需要对 map 进行修改的场景的时候，要格外小心。