## 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
```