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

時間 2021-08-13

標籤 php html git github golang 編程 json 緩存安全數據結構欄目 Go 简体版

原文原文鏈接

前言

Go 是一門簡單有趣的編程語言，與其餘語言同樣，在使用時難免會遇到不少坑，不過它們大多不是 Go 自己的設計缺陷。若是你剛從其餘語言轉到 Go，那這篇文章裏的坑多半會踩到。php

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

初級篇：1-35（二）

18. string 與索引操做符

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

這種處理方式和其餘語言同樣，好比 PHP 中：github

> 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 等很方便的庫函數。golang

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

string 的值沒必要是 UTF8 文本，能夠包含任意的值。只有字符串是文字字面值時纔是 UTF8 文本，字串能夠經過轉義來包含其餘數據。編程

判斷字符串是不是 UTF8 文本，可以使用「unicode/utf8」包中的 ValidString() 函數：json

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