Go控制结构

本文仅是自己阅读笔记，不正确之处请多包涵和纠正。
原文The way to go

我们看到的Go程序都是从main函数开始执行，然后顺序执行该函数体中的代码。但是我们很多时候都需要在代码里进行条件判断。
内容：

• if-else结构
• switch结构
• for结构
• break 与 continue

一、if-else结构

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

if condition {
	// do something	
}

如果存在第二个分支，则可以在上面代码的基础上添加 else 关键字以及另一代码块，这个代码块中的代码只有在条件不满足时才会执行。

if condition {
	// do something	
} else {
	// do something	
}

如果存在第三个分支，则可以使用下面这种三个独立分支的形式：

if condition1 {
	// do something	
} else if condition2 {
	// do something else	
} else {
	// catch-all or default
}

注意：

• else-if 分支的数量是没有限制的，但是为了代码的可读性，还是不要在 if 后面加入太多的 else-if 结构。
• 关键字 if 和 else 之后的左大括号 { 必须和关键字在同一行，如果你使用了 else-if 结构，则前段代码块的右大括号 } 必须和 else-if 关键字在同一行。

二、switch结构

Go 语言中的 switch 结构使用上更加灵活。它接受任意形式的表达式：

1、switch结构的第一种形式

switch var1 {
	case val1:
		...
	case val2:
		...
	default:
		...
}

注意：

• 变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。
• 类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
• 前花括号 { 必须和 switch 关键字在同一行。
• 每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。
• 您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。（只有有一个值符合便进入分支）
• 一旦成功地匹配到某个分支，在执行完相应代码后就会退出整个 switch 代码块，也就是说您不需要特别使用 break 语句来表示结束。因此，程序也不会自动地去执行下一个分支的代码。
• 如果在执行完每个分支的代码后，还希望继续执行后续分支的代码，可以使用 fallthrough 关键字来达到目的。

如下例子：

func main() {
	var num1 int = 99

	switch num1 {
	case 98, 99:
		fmt.Println("It's equal to 98")
	case 100:
		fmt.Println("It's equal to 100")
	default:
		fmt.Println("It's not equal to 98 or 100")
	}
}

输出：

It's equal to 98

func main() {
	var num1 int = 99

	switch num1 {
	case 98, 99:fallthrough
	case 100:
		fmt.Println("It's equal to 100")
		fallthrough
	case 101:
		fmt.Println("It's equal to 101")
		fallthrough
	case 102:
		fmt.Println("It's equal to 102")
	case 103:
		fmt.Println("It's equal to 103")
	default:
		fmt.Println("It's not equal to 98 or 100")
	}
}

输出：

It's equal to 100
It's equal to 101
It's equal to 102

• 您同样可以使用 return 语句来提前结束代码块的执行。当您在 switch 语句块中使用 return 语句，并且您的函数是有返回值的，您还需要在 switch 之后添加相应的 return 语句以确保函数始终会返回。
• 可选的 default 分支可以出现在任何顺序，但最好将它放在最后。

2、switch结构的第二种形式

switch {
	case condition1:
		...
	case condition2:
		...
	default:
		...
}

func main() {
	var num1 int = 7

	switch {
	case num1 < 0:
		fmt.Println("Number is negative")
	case num1 > 0 && num1 < 10:
		fmt.Println("Number is between 0 and 10")
	default:
		fmt.Println("Number is 10 or greater")
	}
}

输出：

Number is between 0 and 10

3、switch结构的第三种形式

switch initialization {
	case val1:
		...
	case val2:
		...
	default:
		...
}

三、for结构

如果想要重复执行某些语句，Go 语言中您只有 for 结构可以使用。

1、基于计数器的迭代

for 初始化语句; 条件语句; 修饰语句 {}

由花括号括起来的代码块会被重复执行已知次数，该次数是根据计数器（此例为 i）决定的。循环开始前，会执行且仅会执行一次初始化语句 i := 0;；这比在循环之前声明更为简短。紧接着的是条件语句 i < 5;，**在每次循环开始前都会进行判断，一旦判断结果为 false，则退出循环体。**最后一部分为修饰语句 i++，一般用于增加或减少计数器。（特别注意，永远不要在循环体内修改计数器，这在任何语言中都是非常差的实践！）

2、基于条件判断的迭代

for 结构的第二种形式是没有头部的条件判断迭代（类似其它语言中的 while 循环），您也可以认为这是没有初始化语句和修饰语句的 for 结构，因此 ;; 便是多余的了。

基本形式为：for 条件语句 {}

3、无限循环

无限for循环的条件语句等被省略，一般写成 for { }
因为 for 循环的头部没有条件语句，那么就会认为条件永远为 true，因此循环体内必须有相关的条件判断以确保会在某个时刻退出循环。

想要直接退出循环体，可以使用 break 语句或 return 语句直接返回。但这两者之间有所区别，break 只是退出当前的循环体，而 return 语句提前对函数进行返回，不会执行后续的代码。

4、for-range结构

是 Go 特有的一种的迭代结构，您会发现它在许多情况下都非常有用。它可以迭代任何一个集合。
一般形式为：for ix, val := range coll { }。

要注意的是，val 始终为集合中对应索引的值拷贝，因此它一般只具有只读性质，对它所做的任何修改都不会影响到集合中原有的值（译者注：如果 val 为指针，则会产生指针的拷贝，依旧可以修改集合中的原值）。

一个字符串是 Unicode 编码的字符（或称之为 rune）集合，因此您也可以用它迭代字符串：

for pos, char := range str {
...
}

值得注意的例子：

for i := 0; i < 5; i++ {
		var v int
		fmt.Printf("%d ", v)
		v = 5
	}

输出：

0 0 0 0 0 

四、break 与 continue

1、break

一个 break 的作用范围为该语句出现后的最内部的结构，它可以被用于任何形式的 for 循环（计数器、条件判断等）。但在 switch 或 select 语句中，break 语句的作用结果是跳过整个代码块，执行后续的代码。

package main

func main() {
	for i:=0; i<3; i++ {
		for j:=0; j<10; j++ {
			if j>5 {
			    break   
			}
			print(j)
		}
		print("  ")
	}
}

输出：

012345 012345 012345

2、continue

关键字 continue 忽略剩余的循环体而直接进入下一次循环的过程，但不是无条件执行下一次循环，执行之前依旧需要满足循环的判断条件。

package main

func main() {
	for i := 0; i < 10; i++ {
		if i == 5 {
			continue
		}
		print(i)
		print(" ")
	}
}

输出：

0 1 2 3 4 6 7 8 9

显然，5 被跳过了。

另外，关键字 continue 只能被用于 for 循环中。