1.2 基础：流程控制语句

一、for

Go只有一种循环结构：for循环。

1. 结构

基本的for循环由三部分组成，之间用分号隔开：

①初始化语句：在第一次迭代前执行

②条件表达式：在每次迭代前求值

③后置语句：在每次迭代的结尾执行

①③可选择不写

package main

import "fmt"

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

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

* 与其他语言不同，Go的for语言后面的三个构成部分外没有小括号，大括号{ }则是必须的。

2. for就是Go中的while

去掉分号，在Go中即是while

package main

import "fmt"

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

3. 无限循环

如果省略循环条件，该循环就不会结束。

package main

func main() {
	for {
	}
}

二、if-else

Go的if语句与for循环类似，表达式外无需小括号，而大括号{ }则是必须的。可以在表达式之前执行一个简短语句，该语句声明的变量作用域仅在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)
	}
	// can't use v here, though
	return lim
}

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

三、switch分支

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

Go只会运行选定的case，而非之后所有的case。在效果上，Go的做法相当于这些语言中为每个case后面自动添加了所需的break语句。在Go中，除非以 fallthrough 语句结束，否则分支会自动终止。

* switch的case无需为常量，且取值不限于整数。

package main

import (
	"fmt"
	"runtime"
)

func main() {
	fmt.Print("Go 运行的系统环境：")
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("macOS.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.\n", os)
	}
}

1. switch的求值顺序 

switch的case语句从上到下顺次执行，知道匹配成功时停止。

例如

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

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

2. 无条件switch

无条件的switch和switch true 一样。这种形式可以将一长串 if - then - else 写的更清晰。

package main

import (
	"fmt"
	"time"
)

func main() {
	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("早上好！")
	case t.Hour() < 17:
		fmt.Println("下午好！")
	default:
		fmt.Println("晚上好！")
	}
}

四、defer推迟

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

package main

import "fmt"

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

	fmt.Println("hello")
}

结果：
hello
world

1. defer栈

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

package main

import "fmt"

func main() {
	fmt.Println("counting")

	for i := 0; i < 5; i++ {
		defer fmt.Println(i)
	}

	fmt.Println("done")
}

结果：
counting
done
4
3
2
1
0

更多关于 defer 语句的信息，请阅读Defer， Panic， and Recover - Go 语言博客 (go-zh.org)