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