GoLang 之旅

Posted 2021-03-17 yc-l

FOR循环

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

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

package main

import "fmt"

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

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

package main

import "fmt"

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

for 是 Go 中的"while"

package main

import "fmt"

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

无限循环

package main

func main() {
	for {
	}
}

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

IF 的简短语句

• 同 for 一样， 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),
	)
}

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
", 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 无需为常量，且取值不必为整数

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

switch 的求值顺序

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 写得更加清晰

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 语句会将函数推迟到外层函数返回之后执行
• 推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用

package main

import "fmt"

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

	fmt.Println("hello")
}

defer 栈

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

package main

import "fmt"

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

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

	fmt.Println("done")
}