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

Goroutine · 發表 2019-01-25 23:23:23

摘要：最近準備寫一些關於golang的技術博文，本文是之前在GitHub上看到的golang技術譯文，感覺很有幫助，先給各位讀者分享一下。前言 Go 是一門簡單有趣的程式語言，與其他語言一樣，在使用時不免會遇到很多坑，不過它們大多不是 Go 本身的設計缺陷。如果你剛從其他語言轉到 Go...

最近準備寫一些關於golang的技術博文，本文是之前在GitHub上看到的golang技術譯文，感覺很有幫助，先給各位讀者分享一下。

前言

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
}

優先順序列表：

PrecedenceOperator
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 的這個例子，可使用一個廢棄 channeldone 來告訴剩餘的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 {
numint
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=%vkey=%vitems=%v\n", d.num, *d.key, d.items)

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

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

執行結果：

本文轉載自https://github.com/wuYin/blog/blob/master/50-shades-of-golang-traps-gotchas-mistakes.md

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

前言

初級篇：1-35（二）

18. string 與索引操作符

19. 字串並不都是 UTF8 文字

20. 字串的長度

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

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

23. 對內建資料結構的操作並不是同步的

24. range 迭代 string 得到的值

25. range 迭代 map

26. switch 中的 fallthrough 語句

27. 自增和自減運算

28. 按位取反

29. 運算子的優先順序

30. 不匯出的 struct 欄位無法被 encode

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

32. 向無緩衝的 channel 傳送資料，只要 receiver 準備好了就會立刻返回

33. 向已關閉的 channel 傳送資料會造成 panic

34. 使用了值為nil 的 channel

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

您可能也會喜歡…

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

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

34. 使用了值為`nil` 的 channel