前言

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

如果花時間學習官方 doc、wiki、討論郵寄清單、 Rob Pike 的大量文章以及 Go 的原始碼，會發現這篇文章中的坑是很常見的，跳過這些坑，能減少大量偵錯程式碼的時間。

1.1.1. 初級篇：1-35

1.左大括號 { 不能單獨放一行

在其他大多數語言中，{ 的位置你自行決定。Go比較特別，遵守分號注入規則（automatic semicolon injection）：編譯器會在每行程式碼尾部特定分隔符後加;來分隔多條語句，比如會在 ) 後加分號：

// 錯誤範例
func main()                    
{
    println("www.baidu.com")
}

// 等效於
func main();    // 無函數體                    
{
    println("hello world")
}

   ./main.go: missing function body
    ./main.go: syntax error: unexpected semicolon or newline before {

// 正確範例
func main() {
    println("www.baidu.com")
}

2.未使用的變數

如果在函數體程式碼中有未使用的變數，則無法通過編譯，不過全域性變數宣告但不使用是可以的。即使變數宣告後為變數賦值，依舊無法通過編譯，需在某處使用它：

// 錯誤範例
var gvar int     // 全域性變數，宣告不使用也可以

func main() {
    var one int     // error: one declared and not used
    two := 2    // error: two declared and not used
    var three int    // error: three declared and not used
    three = 3        
}


// 正確範例
// 可以直接註釋或移除未使用的變數
func main() {
    var one int
    _ = one

    two := 2
    println(two)

    var three int
    one = three

    var four int
    four = four
}

3.未使用的 import

如果你 import一個包，但包中的變數、函數、介面和結構體一個都沒有用到的話，將編譯失敗。可以使用 _下劃線符號作為別名來忽略匯入的包，從而避免編譯錯誤，這隻會執行 package 的 init()

// 錯誤範例
import (
    "fmt"    // imported and not used: "fmt"
    "log"    // imported and not used: "log"
    "time"    // imported and not used: "time"
)

func main() {
}


// 正確範例
// 可以使用 goimports 工具來註釋或移除未使用到的包
import (
    _ "fmt"
    "log"
    "time"
)

func main() {
    _ = log.Println
    _ = time.Now
}

4.簡短宣告的變數只能在函數內部使用

// 錯誤範例
myvar := 1    // syntax error: non-declaration statement outside function body
func main() {
}


// 正確範例
var  myvar = 1
func main() {
}

5.使用簡短宣告來重複宣告變數

不能用簡短宣告方式來單獨為一個變數重複宣告，:=左側至少有一個新變數，才允許多變數的重複宣告：

// 錯誤範例
func main() {  
    one := 0
    one := 1 // error: no new variables on left side of :=
}


// 正確範例
func main() {
    one := 0
    one, two := 1, 2    // two 是新變數，允許 one 的重複宣告。比如 error 處理經常用同名變數 err
    one, two = two, one    // 交換兩個變數值的簡寫
}

6.不能使用簡短宣告來設定欄位的值

struct 的變數欄位不能使用 := 來賦值以使用預定義的變數來避免解決：

// 錯誤範例
type info struct {
    result int
}

func work() (int, error) {
    return 3, nil
}

func main() {
    var data info
    data.result, err := work()    // error: non-name data.result on left side of :=
    fmt.Printf("info: %+v\n", data)
}


// 正確範例
func main() {
    var data info
    var err error    // err 需要預宣告

    data.result, err = work()
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("info: %+v\n", data)
}

7.不小心覆蓋了變數

對從動態語言轉過來的開發者來說，簡短宣告很好用，這可能會讓人誤會 := 是一個賦值操作符。如果你在新的程式碼塊中像下邊這樣誤用了 :=，編譯不會報錯，但是變數不會按你的預期工作：

func main() {
    x := 1
    println(x)        // 1
    {
        println(x)    // 1
        x := 2
        println(x)    // 2    // 新的 x 變數的作用域只在程式碼塊內部
    }
    println(x)        // 1
}

這是 Go 開發者常犯的錯，而且不易被發現。可使用 vet工具來診斷這種變數覆蓋，Go 預設不做覆蓋檢查，新增 -shadow 選項來啟用：

> go tool vet -shadow main.go
main.go:9: declaration of "x" shadows declaration at main.go:5

注意 vet 不會報告全部被覆蓋的變數，可以使用 go-nyet 來做進一步的檢測：

> $GOPATH/bin/go-nyet main.go
main.go:10:3:Shadowing variable `x`

8.顯式型別的變數無法使用 nil 來初始化

nil 是 interface、function、pointer、map、slice 和 channel 型別變數的預設初始值。但宣告時不指定型別，編譯器也無法推斷出變數的具體型別。

// 錯誤範例
func main() {
    var x = nil    // error: use of untyped nil
    _ = x
}


// 正確範例
func main() {
    var x interface{} = nil
    _ = x
}

9.直接使用值為 nil 的 slice、map

允許對值為 nil 的 slice 新增元素，但對值為 nil 的 map新增元素則會造成執行時 panic

// map 錯誤範例
func main() {
    var m map[string]int
    m["one"] = 1        // error: panic: assignment to entry in nil map
    // m := make(map[string]int)// map 的正確宣告，分配了實際的記憶體
}    


// slice 正確範例
func main() {
    var s []int
    s = append(s, 1)
}

10.map 容量

在建立 map 型別的變數時可以指定容量，但不能像 slice 一樣使用 cap() 來檢測分配空間的大小：

// 錯誤範例
func main() {
    m := make(map[string]int, 99)
    println(cap(m))     // error: invalid argument m1 (type map[string]int) for cap  
}

11.string 型別的變數值不能為 nil

對那些喜歡用 nil 初始化字串的人來說，這就是坑：

// 錯誤範例
func main() {
    var s string = nil    // cannot use nil as type string in assignment
    if s == nil {    // invalid operation: s == nil (mismatched types string and nil)
        s = "default"
    }
}


// 正確範例
func main() {
    var s string    // 字串型別的零值是空串 ""
    if s == "" {
        s = "default"
    }
}

12.Array 型別的值作為函數引數

在 C/C++ 中，陣列（名）是指標。將陣列作為引數傳進函數時，相當於傳遞了陣列記憶體地址的參照，在函數內部會改變該陣列的值。

在 Go 中，陣列是值。作為引數傳進函數時，傳遞的是陣列的原始值拷貝，此時在函數內部是無法更新該陣列的：

// 陣列使用值拷貝傳參
func main() {
    x := [3]int{1,2,3}

    func(arr [3]int) {
        arr[0] = 7
        fmt.Println(arr)    // [7 2 3]
    }(x)
    fmt.Println(x)            // [1 2 3]    // 並不是你以為的 [7 2 3]
}

如果想修改引數陣列：

直接傳遞指向這個陣列的指標型別：

// 傳址會修改原資料
func main() {
    x := [3]int{1,2,3}

    func(arr *[3]int) {
        (*arr)[0] = 7    
        fmt.Println(arr)    // &[7 2 3]
    }(&x)
    fmt.Println(x)    // [7 2 3]
}

直接使用 slice：即使函數內部得到的是 slice 的值拷貝，但依舊會更新 slice 的原始資料（底層 array）

// 會修改 slice 的底層 array，從而修改 slice
func main() {
    x := []int{1, 2, 3}
    func(arr []int) {
        arr[0] = 7
        fmt.Println(x)    // [7 2 3]
    }(x)
    fmt.Println(x)    // [7 2 3]
}

13.range 遍歷 slice 和 array 時混淆了返回值

與其他程式語言中的 for-in 、foreach 遍歷語句不同，Go 中的 range 在遍歷時會生成 2 個值，第一個是元素索引，第二個是元素的值：

// 錯誤範例
func main() {
    x := []string{"a", "b", "c"}
    for v := range x {
        fmt.Println(v)    // 1 2 3
    }
}


// 正確範例
func main() {
    x := []string{"a", "b", "c"}
    for _, v := range x {    // 使用 _ 丟棄索引
        fmt.Println(v)
    }
}

14.slice 和 array 其實是一維資料

看起來 Go 支援多維的 array 和 slice，可以建立陣列的陣列、切片的切片，但其實並不是。

對依賴動態計算多維陣列值的應用來說，就效能和複雜度而言，用 Go 實現的效果並不理想。

可以使用原始的一維陣列、「獨立「的切片、「共用底層陣列」的切片來建立動態的多維陣列。

1.使用原始的一維陣列：要做好索引檢查、溢位檢測、以及當陣列滿時再新增值時要重新做記憶體分配。

2.使用「獨立」的切片分兩步：

建立外部 slice
對每個內部 slice 進行記憶體分配
注意內部的 slice 相互獨立，使得任一內部 slice 增縮都不會影響到其他的 slice

// 使用各自獨立的 6 個 slice 來建立 [2][3] 的動態多維陣列
func main() {
    x := 2
    y := 4

    table := make([][]int, x)
    for i  := range table {
        table[i] = make([]int, y)
    }
}

1.使用「共用底層陣列」的切片

建立一個存放原始資料的容器 slice
建立其他的 slice
切割原始 slice 來初始化其他的 slice

func main() {
    h, w := 2, 4
    raw := make([]int, h*w)

    for i := range raw {
        raw[i] = i
    }

    // 初始化原始 slice
    fmt.Println(raw, &raw[4])    // [0 1 2 3 4 5 6 7] 0xc420012120 

    table := make([][]int, h)
    for i := range table {

        // 等間距切割原始 slice，建立動態多維陣列 table
        // 0: raw[0*4: 0*4 + 4]
        // 1: raw[1*4: 1*4 + 4]
        table[i] = raw[i*w : i*w + w]
    }

    fmt.Println(table, &table[1][0])    // [[0 1 2 3] [4 5 6 7]] 0xc420012120
}

15.存取 map 中不存在的 key

和其他程式語言類似，如果存取了 map 中不存在的 key 則希望能返回 nil，比如在 PHP 中：

> php -r '$v = ["x"=>1, "y"=>2]; @var_dump($v["z"]);'
NULL

Go 則會返回元素對應資料型別的零值，比如 nil、'' 、false 和 0，取值操作總有值返回，故不能通過取出來的值來判斷 key 是不是在 map 中。

檢查 key 是否存在可以用 map 直接存取，檢查返回的第二個引數即可：

// 錯誤的 key 檢測方式
func main() {
    x := map[string]string{"one": "2", "two": "", "three": "3"}
    if v := x["two"]; v == "" {
        fmt.Println("key two is no entry")    // 鍵 two 存不存在都會返回的空字串
    }
}

// 正確範例
func main() {
    x := map[string]string{"one": "2", "two": "", "three": "3"}
    if _, ok := x["two"]; !ok {
        fmt.Println("key two is no entry")
    }
}

16.string 型別的值是常數，不可更改

嘗試使用索引遍歷字串，來更新字串中的個別字元，是不允許的。

string 型別的值是唯讀的二進位制 byte slice，如果真要修改字串中的字元，將 string 轉為 []byte 修改後，再轉為 string 即可：

// 修改字串的錯誤範例
func main() {
    x := "text"
    x[0] = "T"        // error: cannot assign to x[0]
    fmt.Println(x)
}


// 修改範例
func main() {
    x := "text"
    xBytes := []byte(x)
    xBytes[0] = 'T'    // 注意此時的 T 是 rune 型別
    x = string(xBytes)
    fmt.Println(x)    // Text
}

注意：上邊的範例並不是更新字串的正確姿勢，因為一個 UTF8 編碼的字元可能會佔多個位元組，比如漢字就需要 3~4個位元組來儲存，此時更新其中的一個位元組是錯誤的。

更新字串的正確姿勢：將 string 轉為 rune slice（此時 1 個 rune 可能佔多個 byte），直接更新 rune 中的字元

func main() {
    x := "text"
    xRunes := []rune(x)
    xRunes[0] = '我'
    x = string(xRunes)
    fmt.Println(x)    // 我ext
}

17.string 與 byte slice 之間的轉換

當進行 string 和 byte slice 相互轉換時，參與轉換的是拷貝的原始值。這種轉換的過程，與其他程式設計語的強制型別轉換操作不同，也和新 slice 與舊 slice 共用底層陣列不同。

Go 在 string 與 byte slice 相互轉換上優化了兩點，避免了額外的記憶體分配：

在 map[string] 中查詢 key 時，使用了對應的 []byte，避免做 m[string(key)] 的記憶體分配
使用 for range 迭代 string 轉換為 []byte 的迭代：for i,v := range []byte(str) {...}

18.string 與索引操作符

對字串用索引存取返回的不是字元，而是一個 byte 值。

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 的組合
}

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：

針對上邊有 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)
}

執行結果：

參考轉自：http://devs.cloudimmunity.com/gotchas-and-common-mistakes-in-go-golang/index.html

Golang可能會踩的58個坑之初級篇

前言

1.1.1. 初級篇：1-35

1.左大括號 { 不能單獨放一行

2.未使用的變數

3.未使用的 import

4.簡短宣告的變數只能在函數內部使用

5.使用簡短宣告來重複宣告變數

6.不能使用簡短宣告來設定欄位的值

7.不小心覆蓋了變數

8.顯式型別的變數無法使用 nil 來初始化

9.直接使用值為 nil 的 slice、map

10.map 容量

11.string 型別的變數值不能為 nil

12.Array 型別的值作為函數引數

13.range 遍歷 slice 和 array 時混淆了返回值

14.slice 和 array 其實是一維資料

15.存取 map 中不存在的 key

16.string 型別的值是常數，不可更改

17.string 與 byte slice 之間的轉換

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 傳參是傳值方式，則無法修改引數的原有值