## if-else 结构
关键字 if 和 else 之后的左大括号 { 必须和关键字在同一行，如果你使用了 else-if 结构，则前段代码块的右大括号 } 必须和 else-if 关键字在同一行。这两条规则都是被编译器强制规定的。
```
// 非法代码
if condition{
}
else { // 无效的
}
```
在有些情况下，条件语句两侧的括号是可以被省略的；当条件比较复杂时，则可以使用括号让代码更易读。条件允许是符合条件，需使用 &&、|| 或！，你可以使用括号来提升某个表达式的运算优先级，并提高代码的可读性。
```
package main
import "fmt"
func main() {
bool1 := true
if bool1 {
fmt.Printf("The value is true\n")
} else {
fmt.Printf("The value is false\n")
}
}
```
当 if 结构内有 break、continue、goto 或者 return 语句时，Go 代码的常见写法是省略 else 部分。无论满足哪个条件都会返回 x 或者 y 时，一般使用以下写法：
```
if condition {
return x
}
return y
```
获取操作系统信息
```
package main
import (
"fmt"
"runtime"
)
func main() {
os := runtime.GOOS
if os == "windows" {
fmt.Println("windows")
} else if os == "linux" {
fmt.Println("linux")
} else {
fmt.Println("darwin")
}
}
```
## switch 结构
```
switch var1 {
case val1:
...
case val2:
...
default:
...
}
```
变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。前花括号 { 必须和 switch 关键字在同一行。
您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。
```
switch var1 {
case val1, val2:
...
case val3:
...
default:
...
}
```
一旦成功地匹配到某个分支，在执行完相应代码后就会退出整个 switch 代码块，也就是说您不需要特别使用 break 语句来表示结束。
因此，程序也不会自动地去执行下一个分支的代码。如果在执行完每个分支的代码后，还希望继续执行后续分支的代码，可以使用 fallthrough 关键字来达到目的。
使用了 fallthrough 关键字后不管下一个 case 语句有没有匹配成功都会执行，但是一个 fallthrough 只会执行下一个 case ，如果使用了 fallthrough，但是后面没有语句则会编译报错
```
package main
import "fmt"
func main() {
i := 0
switch i {
case 0: fallthrough
case 1:
f1() // 当 i == 0 时函数也会被调用，此处如果还有 fallthrough 则后面 case 将被继续执行
}
case 2: f2()
}
func f1(){
fmt.Println("this is f1")
}
func f2(){
fmt.Println("this is f2")
}
```
switch 语句的第二种形式是不提供任何被判断的值（实际上默认为判断是否为 true），然后在每个 case 分支中进行测试不同的条件。当任一分支的测试结果为 true 时，该分支的代码会被执行。这看起来非常像链式的 if-else 语句，但是在测试条件非常多的情况下，提供了可读性更好的书写方式。
```
package main
import "fmt"
func main() {
num := 7
switch {
case num < 0:
fmt.Println("Number is negative")
case num > 0 && num < 10:
fmt.Println("Number is between 0 and 10")
default:
fmt.Println("Number is 10 or greater")
}
}
// 打印：Number is between 0 and 10
```
switch 语句的第三种形式是包含一个初始化语句：
```
package main
import "fmt"
func main() {
switch result := f1(); {
case result < 0: fmt.Println("result < 0")
case result > 0: fmt.Println("result > 0")
default:
fmt.Println("result = 0")
}
}
func f1() int {
return 1
}
```
## for 结构
### 基于计数器的迭代
基本形式为：
`for 初始化语句; 条件语句; 修饰语句 {}`
```
package main
import "fmt"
func main() {
for i := 0; i < 5; i++ {
fmt.Printf("This is the %d iteration\n", i)
}
}
```
### 基于条件判断的迭代
for 结构的第二种形式是没有头部的条件判断迭代（类似其它语言中的 while 循环），基本形式为：for 条件语句 {}。
您也可以认为这是没有初始化语句和修饰语句的 for 结构，因此 ;; 便是多余的了。
```
package main
import "fmt"
func main() {
var i int = 5
for i >= 0 {
i = i - 1
fmt.Printf("The variable i is now: %d\n", i)
}
}
```
### 无线循环
条件语句是可以被省略的，如 i:=0; ; i++ 或 for { } 或 for ;; { }（;; 会在使用 gofmt 时被移除）：这些循环的本质就是无限循环。最后一个形式也可以被改写为 for true { }，但一般情况下都会直接写 for { }。
如果 for 循环的头部没有条件语句，那么就会认为条件永远为 true，因此循环体内必须有相关的条件判断以确保会在某个时刻退出循环。
想要直接退出循环体，可以使用 break 语句或 return 语句直接返回。
但这两者之间有所区别，break 只是退出当前的循环体，而 return 语句提前对函数进行返回，不会执行后续的代码。
无限循环的经典应用是服务器，用于不断等待和接受新的请求。
### for-range 结构
它可以迭代任何一个集合，语法上很类似其它语言中 foreach 语句般形式为：
`for ix, val := range coll { }`
要注意的是，val 始终为集合中对应索引的值拷贝，因此它一般只具有只读性质，对它所做的任何修改都不会影响到集合中原有的值（**如果 val 为指针，则会产生指针的拷贝，依旧可以修改集合中的原值**）。一个字符串是 Unicode 编码的字符（或称之为 rune）集合，因此您也可以用它迭代字符串：
```
package main
import "fmt"
func main() {
str := "Go is a beautiful language!"
fmt.Printf("The length of str is: %d\n", len(str))
for pos, char := range str {
fmt.Printf("Character on position %d is: %c \n", pos, char)
}
}
```
下面这段代码会造成死循环吗？
```
package main
import "fmt"
func main() {
s := []int{1,2,3,4,5}
for _, v:=range s {
s =append(s, v)
fmt.Printf("len(s)=%v\n",len(s))
}
}
```
for range 源码
```
// The loop we generate:
// for_temp := range
// len_temp := len(for_temp)
// for index_temp = 0; index_temp < len_temp; index_temp++ {
// value_temp = for_temp[index_temp]
// index = index_temp
// value = value_temp
// original body
// }
```
不会死循环，for range其实是golang的语法糖，在循环开始前会获取切片的长度 len(切片)，然后再执行len(切片)次数的循环。
上面的代码会被编译器认为是
```
func main() {
s := []int{1,2,3,4,5}
for_temp := s
len_temp := len(for_temp)
for index_temp := 0; index_temp < len_temp; index_temp++ {
value_temp := for_temp[index_temp]
_ = index_temp
value := value_temp
// 以下是 original body
s =append(s, value)
fmt.Printf("len(s)=%v\n",len(s))
}
}
```
代码运行输出
```
len(s)=6
len(s)=7
len(s)=8
len(s)=9
len(s)=10
```