Go语言之旅中文网站：Go语言之旅

一、for

1.1 for 说明

Go 只有一种循环结构：for 循环。
基本的 for 循环由三部分组成，它们用分号隔开：

初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行

初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的 作用域 中可见。
一旦条件表达式的布尔值为 false，循环迭代就会终止。

例子：

package main

import "fmt"

func main() {
    sum := 0
    for i := 0; i < 10; i++ {
        sum += i
    }
    fmt.Println(sum)
}

注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号，大括号 { } 则是必须的。

另外，初始化语句和后置语句是可选的。例如：

package main

import "fmt"

func main() {
    sum := 1
    for ; sum < 1000; {
        sum += sum
    }
    fmt.Println(sum)
}

1.2 for 变身为“while”

上面的例子中，如果去掉分号，Go 中的 for 就类似于 C 中的 while 语句。如下：

package main

import "fmt"

func main() {
    sum := 1
    for sum < 1000 {
        sum += sum
    }
    fmt.Println(sum)
}

1.3 无限循环

如果省略循环条件，该循环就不会结束，因此无限循环可以写得很紧凑。

package main

func main() {
    for {
    }
}

二、if

2.1 if 说明

Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。
例子：

package main

import (
    "fmt"
    "math"
)

func sqrt(x float64) string {
    if x < 0 {
        return sqrt(-x) + "i"
    }
    return fmt.Sprint(math.Sqrt(x))
}

func main() {
    fmt.Println(sqrt(2), sqrt(-4))
}

提示：fmt.Sprint() 是为了将 math.Sqrt() 的结果转换为 string 类型，然后才可以与 if 里面的 “i” 拼接。因为，在Go中，字符串与数字不能直接使用 “+” 拼接。

2.2 if的简短语句

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。
该语句声明的 变量作用域 仅在 if 之内。

例子：

package main

import (
    "fmt"
    "math"
)

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    }
    return lim
}

func main() {
    fmt.Println(
    pow(3, 2, 10),
        pow(3, 3, 20),
    )
}

2.3 if 和 else

在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。
例子：

package main

import (
    "fmt"
    "math"
)

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    } else {
        fmt.Printf("%g >= %g\n", v, lim)
    }
    // 这里开始就不能使用 v 了
    return lim
}

func main() {
    fmt.Println(
        pow(3, 2, 10),
        pow(3, 3, 20),
    )
}

三、switch

3.1 switch 说明

switch 是编写一连串 if - else 语句的简便方法。
它运行第一个值等于条件表达式的 case 语句。

Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的，不过 Go 只运行选定的 case，而非之后所有的 case。

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Print("Go runs on ")
    switch os := runtime.GOOS; os {
    case "darwin":
        fmt.Println("OS X.")
    case "linux":
        fmt.Println("Linux.")
    default:
        // freebsd, openbsd,
        // plan9, windows...
        fmt.Printf("%s.\n", os)
    }
}

实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。除非以 fallthrough 语句结束，否则分支会自动终止。举个例子：

package main

import (
    "fmt"
)

func main() {
    switch i := 12; i {
    case 10:
        fmt.Println("Case-10")
    case 12:
        fmt.Println("Case-12")
    default:
        fmt.Printf("Case-Default!")
    }
}

上面的例子输出的输出结果：

PS C:\Users\opstips\Desktop\goroot> go run control.go
Case-12

接下来，在上面的例子中，加入fallthrough

package main

import (
    "fmt"
)

func main() {
    switch i := 12; i {
    case 10:
        fmt.Println("Case-10")
        fallthrough
    case 12:
        fmt.Println("Case-12")
        fallthrough
    default:
        fmt.Printf("Case-Default!")
    }
}

输出结果：

PS C:\Users\apple\Desktop\goroot> go run control.go
Case-12
Case-Default!

可以看到，由于以 fallthrough 语句结束，运行完选定 case 之后，分支未自动终止，继续向下运行。

另外，Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

3.2 switch 的求值顺序

switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。
例如：

switch i {
case 0:
case f():
}

在 i==0 时 f 不会被调用。

例子：

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("When's Saturday?")
    today := time.Now().Weekday()
    switch time.Saturday {
    case today + 0:
        fmt.Println("Today.")
    case today + 1:
        fmt.Println("Tomorrow.")
    case today + 2:
        fmt.Println("In two days.")
    default:
        fmt.Println("Too far away.")
    }
}

3.3 没有条件的 switch

没有条件的 switch 同 switch true 一样。
这种形式能将一长串 if-then-else 写得更加清晰。

例子：

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("Good morning!")
    case t.Hour() < 17:
        fmt.Println("Good afternoon.")
    default:
        fmt.Println("Good evening.")
    }
}

四、defer

4.1 defer 说明

defer 语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

例子：

package main

import "fmt"

func main() {
    defer fmt.Println("world")
    fmt.Println("hello")
}

虽然代码顺序上 fmt.Println("world") 在 fmt.Println("hello") 之前，但结果是先输出“hello”，再输出“world”。

4.2 defer 栈

推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

例子：

package main

import "fmt"

func main() {
    fmt.Println("counting")
    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }
    fmt.Println("done")
}