GoLang 之旅（二）

FOR循环#

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

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

?

1 2 3 4 5 6 7 8 9 10 11

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

• 初始化语句和后置语句是可选的

?

1 2 3 4 5 6 7 8 9 10 11

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

for 是 Go 中的"while"#

?

1 2 3 4 5 6 7 8 9 10 11

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

无限循环#

?

1 2 3 4 5 6

package main   func main() {     for {     } }

IF#

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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)) }

IF 的简短语句#

• 同 for 一样， if 语句可以在条件表达式前执行一个简单的语句

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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),     ) }

if 和 else#

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

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#

• 实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句
• 除非以 fallthrough 语句结束，否则分支会自动终止。
• Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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)     } }

switch 的求值顺序#

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

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.")     } }

没有条件的 switch#

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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#

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

?

1 2 3 4 5 6 7 8 9

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

defer 栈#

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13

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