Golang 需要避免踩的 50 個坑（二）

前言

Go 是一門簡單有趣的編程語言，與其他語言一樣，在使用時不免會遇到很多坑，不過它們大多不是 Go 本身的設計缺陷。如果你剛從其他語言轉到 Go，那這篇文章里的坑多半會踩到。

如果花時間學習官方 doc、wiki、討論郵件列表、 Rob Pike 的大量文章以及 Go 的源碼，會發現這篇文章中的坑是很常見的，新手跳過這些坑，能減少大量調試代碼的時間。

初級篇：1-35（二）

18. string 與索引操作符

對字符串用索引訪問返回的不是字符，而是一個 byte 值。

這種處理方式和其他語言一樣，比如 PHP 中：

> php -r '$name="中文"; var_dump($name);'	# "中文" 占用 6 個字節
string(6) "中文"

> php -r '$name="中文"; var_dump($name[0]);' # 把第一個字節當做 Unicode 字符讀取，顯示 U+FFFD
string(1) "�"	

> php -r '$name="中文"; var_dump($name[0].$name[1].$name[2]);'
string(3) "中"
func main() {
	x := "ascii"
	fmt.Println(x[0])		// 97
	fmt.Printf("%T\n", x[0])// uint8
}

　　

如果需要使用 for range 迭代訪問字符串中的字符（unicode code point / rune），標准庫中有 "unicode/utf8" 包來做 UTF8 的相關解碼編碼。另外 utf8string 也有像 func (s *String) At(i int) rune 等很方便的庫函數。

19. 字符串並不都是 UTF8 文本

string 的值不必是 UTF8 文本，可以包含任意的值。只有字符串是文字字面值時才是 UTF8 文本，字串可以通過轉義來包含其他數據。

判斷字符串是否是 UTF8 文本，可使用 “unicode/utf8” 包中的 ValidString() 函數：

func main() {
	str1 := "ABC"
	fmt.Println(utf8.ValidString(str1))	// true

	str2 := "A\xfeC"
	fmt.Println(utf8.ValidString(str2))	// false

	str3 := "A\\xfeC"
	fmt.Println(utf8.ValidString(str3))	// true	// 把轉義字符轉義成字面值
}

20. 字符串的長度

在 Python 中：

data = u'♥'
print(len(data)) # 1

然而在 Go 中：

func main() {
	char := "♥"
	fmt.Println(len(char))	// 3
}

　　

Go 的內建函數 len() 返回的是字符串的 byte 數量，而不是像 Python 中那樣是計算 Unicode 字符數。

如果要得到字符串的字符數，可使用 “unicode/utf8” 包中的 RuneCountInString(str string) (n int)

func main() {
	char := "♥"
	fmt.Println(utf8.RuneCountInString(char))	// 1
}

　　注意： RuneCountInString 並不總是返回我們看到的字符數，因為有的字符會占用 2 個 rune：

func main() {
	char := "é"
	fmt.Println(len(char))	// 3
	fmt.Println(utf8.RuneCountInString(char))	// 2
	fmt.Println("cafe\u0301")	// café	// 法文的 cafe，實際上是兩個 rune 的組合
}

　　

參考：normalization

21. 在多行 array、slice、map 語句中缺少 , 號

func main() {
	x := []int {
		1,
		2	// syntax error: unexpected newline, expecting comma or }
	}
	y := []int{1,2,}	
	z := []int{1,2}	
	// ...
}

　　

聲明語句中 } 折疊到單行后，尾部的 , 不是必需的。

22. log.Fatal 和 log.Panic 不只是 log

log 標准庫提供了不同的日志記錄等級，與其他語言的日志庫不同，Go 的 log 包在調用 Fatal*()、Panic*() 時能做更多日志外的事，如中斷程序的執行等：

func main() {
	log.Fatal("Fatal level log: log entry")		// 輸出信息后，程序終止執行
	log.Println("Nomal level log: log entry")
}

　　

23. 對內建數據結構的操作並不是同步的

盡管 Go 本身有大量的特性來支持並發，但並不保證並發的數據安全，用戶需自己保證變量等數據以原子操作更新。

goroutine 和 channel 是進行原子操作的好方法，或使用 “sync” 包中的鎖。

24. range 迭代 string 得到的值

range 得到的索引是字符值（Unicode point / rune）第一個字節的位置，與其他編程語言不同，這個索引並不直接是字符在字符串中的位置。

注意一個字符可能占多個 rune，比如法文單詞 café 中的 é。操作特殊字符可使用norm 包。

for range 迭代會嘗試將 string 翻譯為 UTF8 文本，對任何無效的碼點都直接使用 0XFFFD rune（�）UNicode 替代字符來表示。如果 string 中有任何非 UTF8 的數據，應將 string 保存為 byte slice 再進行操作。

func main() {
	data := "A\xfe\x02\xff\x04"
	for _, v := range data {
		fmt.Printf("%#x ", v)	// 0x41 0xfffd 0x2 0xfffd 0x4	// 錯誤
	}

	for _, v := range []byte(data) {
		fmt.Printf("%#x ", v)	// 0x41 0xfe 0x2 0xff 0x4	// 正確
	}
}

　　

25. range 迭代 map

如果你希望以特定的順序（如按 key 排序）來迭代 map，要注意每次迭代都可能產生不一樣的結果。

Go 的運行時是有意打亂迭代順序的，所以你得到的迭代結果可能不一致。但也並不總會打亂，得到連續相同的 5 個迭代結果也是可能的，如：

func main() {
	m := map[string]int{"one": 1, "two": 2, "three": 3, "four": 4}
	for k, v := range m {
		fmt.Println(k, v)
	}
}

　　

如果你去 Go Playground 重復運行上邊的代碼，輸出是不會變的，只有你更新代碼它才會重新編譯。重新編譯后迭代順序是被打亂的：

26. switch 中的 fallthrough 語句

switch 語句中的 case 代碼塊會默認帶上 break，但可以使用 fallthrough 來強制執行下一個 case 代碼塊。

func main() {
	isSpace := func(char byte) bool {
		switch char {
		case ' ':	// 空格符會直接 break，返回 false // 和其他語言不一樣
		// fallthrough	// 返回 true
		case '\t':
			return true
		}
		return false
	}
	fmt.Println(isSpace('\t'))	// true
	fmt.Println(isSpace(' '))	// false
}

　　

不過你可以在 case 代碼塊末尾使用 fallthrough，強制執行下一個 case 代碼塊。

也可以改寫 case 為多條件判斷：

func main() {
	isSpace := func(char byte) bool {
		switch char {
		case ' ', '\t':
			return true
		}
		return false
	}
	fmt.Println(isSpace('\t'))	// true
	fmt.Println(isSpace(' '))	// true
}

　　

27. 自增和自減運算

很多編程語言都自帶前置后置的 ++、-- 運算。但 Go 特立獨行，去掉了前置操作，同時 ++、— 只作為運算符而非表達式。

// 錯誤示例
func main() {
	data := []int{1, 2, 3}
	i := 0
	++i			// syntax error: unexpected ++, expecting }
	fmt.Println(data[i++])	// syntax error: unexpected ++, expecting :
}


// 正確示例
func main() {
	data := []int{1, 2, 3}
	i := 0
	i++
	fmt.Println(data[i])	// 2
}

　　

28. 按位取反

很多編程語言使用 ~ 作為一元按位取反（NOT）操作符，Go 重用 ^ XOR 操作符來按位取反：

// 錯誤的取反操作
func main() {
	fmt.Println(~2)		// bitwise complement operator is ^
}


// 正確示例
func main() {
	var d uint8 = 2
	fmt.Printf("%08b\n", d)		// 00000010
	fmt.Printf("%08b\n", ^d)	// 11111101
}

　　

同時 ^ 也是按位異或（XOR）操作符。

一個操作符能重用兩次，是因為一元的 NOT 操作 NOT 0x02，與二元的 XOR 操作 0x22 XOR 0xff 是一致的。

Go 也有特殊的操作符 AND NOT &^ 操作符，不同位才取1。

func main() {
	var a uint8 = 0x82
	var b uint8 = 0x02
	fmt.Printf("%08b [A]\n", a)
	fmt.Printf("%08b [B]\n", b)

	fmt.Printf("%08b (NOT B)\n", ^b)
	fmt.Printf("%08b ^ %08b = %08b [B XOR 0xff]\n", b, 0xff, b^0xff)

	fmt.Printf("%08b ^ %08b = %08b [A XOR B]\n", a, b, a^b)
	fmt.Printf("%08b & %08b = %08b [A AND B]\n", a, b, a&b)
	fmt.Printf("%08b &^%08b = %08b [A 'AND NOT' B]\n", a, b, a&^b)
	fmt.Printf("%08b&(^%08b)= %08b [A AND (NOT B)]\n", a, b, a&(^b))
}

　　

10000010 [A]
00000010 [B]
11111101 (NOT B)
00000010 ^ 11111111 = 11111101 [B XOR 0xff]
10000010 ^ 00000010 = 10000000 [A XOR B]
10000010 & 00000010 = 00000010 [A AND B]
10000010 &^00000010 = 10000000 [A 'AND NOT' B]
10000010&(^00000010)= 10000000 [A AND (NOT B)]

　　

29. 運算符的優先級

除了位清除（bit clear）操作符，Go 也有很多和其他語言一樣的位操作符，但優先級另當別論

func main() {
	fmt.Printf("0x2 & 0x2 + 0x4 -> %#x\n", 0x2&0x2+0x4)	// & 優先 +
	//prints: 0x2 & 0x2 + 0x4 -> 0x6
	//Go:    (0x2 & 0x2) + 0x4
	//C++:    0x2 & (0x2 + 0x4) -> 0x2

	fmt.Printf("0x2 + 0x2 << 0x1 -> %#x\n", 0x2+0x2<<0x1)	// << 優先 +
	//prints: 0x2 + 0x2 << 0x1 -> 0x6
	//Go:     0x2 + (0x2 << 0x1)
	//C++:   (0x2 + 0x2) << 0x1 -> 0x8

	fmt.Printf("0xf | 0x2 ^ 0x2 -> %#x\n", 0xf|0x2^0x2)	// | 優先 ^
	//prints: 0xf | 0x2 ^ 0x2 -> 0xd
	//Go:    (0xf | 0x2) ^ 0x2
	//C++:    0xf | (0x2 ^ 0x2) -> 0xf
}

　　優先級列表：

Precedence    Operator
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

　　

30. 不導出的 struct 字段無法被 encode
以小寫字母開頭的字段成員是無法被外部直接訪問的，所以 struct 在進行 json、xml、gob 等格式的 encode 操作時，這些私有字段會被忽略，導出時得到零值：

　　

func main() {
	in := MyData{1, "two"}
	fmt.Printf("%#v\n", in)	// main.MyData{One:1, two:"two"}

	encoded, _ := json.Marshal(in)
	fmt.Println(string(encoded))	// {"One":1}	// 私有字段 two 被忽略了

	var out MyData
	json.Unmarshal(encoded, &out)
	fmt.Printf("%#v\n", out) 	// main.MyData{One:1, two:""}
}

　　

31. 程序退出時還有 goroutine 在執行

程序默認不等所有 goroutine 都執行完才退出，這點需要特別注意：

// 主程序會直接退出
func main() {
	workerCount := 2
	for i := 0; i < workerCount; i++ {
		go doIt(i)
	}
	time.Sleep(1 * time.Second)
	fmt.Println("all done!")
}

func doIt(workerID int) {
	fmt.Printf("[%v] is running\n", workerID)
	time.Sleep(3 * time.Second)		// 模擬 goroutine 正在執行 
	fmt.Printf("[%v] is done\n", workerID)
}

　　

如下，main() 主程序不等兩個 goroutine 執行完就直接退出了：

常用解決辦法：使用 “WaitGroup” 變量，它會讓主程序等待所有 goroutine 執行完畢再退出。

如果你的 goroutine 要做消息的循環處理等耗時操作，可以向它們發送一條 kill 消息來關閉它們。或直接關閉一個它們都等待接收數據的 channel：

// 等待所有 goroutine 執行完畢
// 進入死鎖
func main() {
	var wg sync.WaitGroup
	done := make(chan struct{})

	workerCount := 2
	for i := 0; i < workerCount; i++ {
		wg.Add(1)
		go doIt(i, done, wg)
	}

	close(done)
	wg.Wait()
	fmt.Println("all done!")
}

func doIt(workerID int, done <-chan struct{}, wg sync.WaitGroup) {
	fmt.Printf("[%v] is running\n", workerID)
	defer wg.Done()
	<-done
	fmt.Printf("[%v] is done\n", workerID)
}

　　

執行結果：

看起來好像 goroutine 都執行完了，然而報錯：

fatal error: all goroutines are asleep - deadlock!

為什么會發生死鎖？goroutine 在退出前調用了 wg.Done() ，程序應該正常退出的。

原因是 goroutine 得到的 “WaitGroup” 變量是 var wg WaitGroup 的一份拷貝值，即 doIt() 傳參只傳值。所以哪怕在每個 goroutine 中都調用了 wg.Done()， 主程序中的 wg 變量並不會受到影響。

// 等待所有 goroutine 執行完畢
// 使用傳址方式為 WaitGroup 變量傳參
// 使用 channel 關閉 goroutine

func main() {
	var wg sync.WaitGroup
	done := make(chan struct{})
	ch := make(chan interface{})

	workerCount := 2
	for i := 0; i < workerCount; i++ {
		wg.Add(1)
        go doIt(i, ch, done, &wg)	// wg 傳指針，doIt() 內部會改變 wg 的值
	}

	for i := 0; i < workerCount; i++ {	// 向 ch 中發送數據，關閉 goroutine
		ch <- i
	}

	close(done)
	wg.Wait()
	close(ch)
	fmt.Println("all done!")
}

func doIt(workerID int, ch <-chan interface{}, done <-chan struct{}, wg *sync.WaitGroup) {
	fmt.Printf("[%v] is running\n", workerID)
	defer wg.Done()
	for {
		select {
		case m := <-ch:
			fmt.Printf("[%v] m => %v\n", workerID, m)
		case <-done:
			fmt.Printf("[%v] is done\n", workerID)
			return
		}
	}
}

　　

運行效果：

32. 向無緩沖的 channel 發送數據，只要 receiver 准備好了就會立刻返回

只有在數據被 receiver 處理時，sender 才會阻塞。因運行環境而異，在 sender 發送完數據后，receiver 的 goroutine 可能沒有足夠的時間處理下一個數據。如：

func main() {
	ch := make(chan string)

	go func() {
		for m := range ch {
			fmt.Println("Processed:", m)
			time.Sleep(1 * time.Second)	// 模擬需要長時間運行的操作
		}
	}()

	ch <- "cmd.1"
	ch <- "cmd.2" // 不會被接收處理
}

　　

運行效果：

33. 向已關閉的 channel 發送數據會造成 panic

從已關閉的 channel 接收數據是安全的：

接收狀態值 ok 是 false 時表明 channel 中已沒有數據可以接收了。類似的，從有緩沖的 channel 中接收數據，緩存的數據獲取完再沒有數據可取時，狀態值也是 false

向已關閉的 channel 中發送數據會造成 panic：

func main() {
	ch := make(chan int)
	for i := 0; i < 3; i++ {
		go func(idx int) {
			ch <- idx
		}(i)
	}

	fmt.Println(<-ch)		// 輸出第一個發送的值
	close(ch)			// 不能關閉，還有其他的 sender
	time.Sleep(2 * time.Second)	// 模擬做其他的操作
}

　　

運行結果：

針對上邊有 bug 的這個例子，可使用一個廢棄 channel done 來告訴剩余的 goroutine 無需再向 ch 發送數據。此時 <- done 的結果是 {}：

func main() {
	ch := make(chan int)
	done := make(chan struct{})

	for i := 0; i < 3; i++ {
		go func(idx int) {
			select {
			case ch <- (idx + 1) * 2:
				fmt.Println(idx, "Send result")
			case <-done:
				fmt.Println(idx, "Exiting")
			}
		}(i)
	}

	fmt.Println("Result: ", <-ch)
	close(done)
	time.Sleep(3 * time.Second)
}

　　

運行效果：

34. 使用了值為 nil 的 channel

在一個值為 nil 的 channel 上發送和接收數據將永久阻塞：

func main() {
	var ch chan int // 未初始化，值為 nil
	for i := 0; i < 3; i++ {
		go func(i int) {
			ch <- i
		}(i)
	}

	fmt.Println("Result: ", <-ch)
	time.Sleep(2 * time.Second)

　　

runtime 死鎖錯誤：

fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive (nil chan)]

利用這個死鎖的特性，可以用在 select 中動態的打開和關閉 case 語句塊：

func main() {
	inCh := make(chan int)
	outCh := make(chan int)

	go func() {
		var in <-chan int = inCh
		var out chan<- int
		var val int

		for {
			select {
			case out <- val:
				println("--------")
				out = nil
				in = inCh
			case val = <-in:
				println("++++++++++")
				out = outCh
				in = nil
			}
		}
	}()

	go func() {
		for r := range outCh {
			fmt.Println("Result: ", r)
		}
	}()

	time.Sleep(0)
	inCh <- 1
	inCh <- 2
	time.Sleep(3 * time.Second)

　　

運行效果：

35. 若函數 receiver 傳參是傳值方式，則無法修改參數的原有值

方法 receiver 的參數與一般函數的參數類似：如果聲明為值，那方法體得到的是一份參數的值拷貝，此時對參數的任何修改都不會對原有值產生影響。

除非 receiver 參數是 map 或 slice 類型的變量，並且是以指針方式更新 map 中的字段、slice 中的元素的，才會更新原有值:

 

type data struct {
	num   int
	key   *string
	items map[string]bool
}

func (this *data) pointerFunc() {
	this.num = 7
}

func (this data) valueFunc() {
	this.num = 8
	*this.key = "valueFunc.key"
	this.items["valueFunc"] = true
}

func main() {
	key := "key1"

	d := data{1, &key, make(map[string]bool)}
	fmt.Printf("num=%v  key=%v  items=%v\n", d.num, *d.key, d.items)

	d.pointerFunc()	// 修改 num 的值為 7
	fmt.Printf("num=%v  key=%v  items=%v\n", d.num, *d.key, d.items)

	d.valueFunc()	// 修改 key 和 items 的值
	fmt.Printf("num=%v  key=%v  items=%v\n", d.num, *d.key, d.items)
}