• 第一，和 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")
  }
  

  

• 仅使用单分支控制结构；
• 当布尔表达式求值为 false 时，也就是出现错误时，在单分支中快速返回；
• 正常逻辑在代码布局上始终“靠左”，这样读者可以从上到下一眼看到该函数正常逻辑的全貌；
• 函数执行到最后一行代表一种成功状态。

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 语句中使用的所有表达式的求值结果只能是 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 代码逻辑的语义。

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 中的类型进行匹配，之后的逻辑就都是一样的了。

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

• 我们通常会在这个部分声明一些循环体（③ ）或循环控制条件（② ）会用到的自用变量，也称循环变量或迭代变量，比如这里声明的整型变量 i。
• 与 if 语句中的自用变量一样，for 循环变量也采用短变量声明的形式，循环变量的作用域仅限于 for 语句隐式代码块范围内。

• 和 if 语句的一样，这个用于条件判断的表达式必须为布尔表达式，如果有多个判断条件，我们一样可以由逻辑操作符进行连接。
• 当表达式的求值结果为 true 时，代码将进入循环体（③）继续执行，相反则循环直接结束，循环体（③）与组成部分④都不会被执行。

• 如果相关的判断条件表达式求值结构为 true 时，循环体就会被执行一次，这样的一次执行也被称为一次迭代（Iteration）。
• 在上面例子中，循环体执行的动作是将这次迭代中变量 i 的值累加到变量 sum 中。

• 这个部分通常用于更新 for 循环语句组成部分①中声明的循环变量，比如在这个例子中，我们在这个组成部分对循环变量 i 进行加 1 操作。

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 循环就是我们通常所说的“无限循环”。

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 经典形式下的循环后置语句执行的逻辑是相同的。

• 变种一：当我们不关心元素的值时，我们可以省略代表元素值的变量 v，只声明代表下标值的变量 i。
• 变种二：如果我们不关心元素下标，只关心元素值，那么我们可以用空标识符替代代表下标值的变量 i。这里一定要注意，这个空标识符不能省略，否则就与上面的“变种一”形式一样了，Go 编译器将无法区分。
• 变种三：如果我们既不关心下标值，也不关心元素值，可以将 i，v 都省略。

var c = make(chan int)
for v := range c {
	// ...
}

• for range 每次从 channel 中读取一个元素后，会把它赋值给循环变量 v，并进入循环体。当 channel 中没有数据可读的时候，for range 循环会阻塞在对 channel 的读操作上。
• 直到 channel 关闭时，for range 循环才会结束，这也是 for range 循环与 channel 配合时隐含的循环判断条件。

• 如果循环体中的代码执行到一半，要中断当前迭代，忽略此迭代循环体中的后续代码，并回到 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
    			}
    		}
    	}
    }
    

• for range 形式的循环语句，使用短变量声明的方式来声明循环变量，循环体将使用这些循环变量实现特定的逻辑，但在使用的时候，可能会发现循环变量的值与“预期”不符。
• 有时候循环变量在 for 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 进行修改的场景的时候，要格外小心。