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

前言

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

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

中級篇：35-50

35. 關閉 HTTP 的響應體

使用 HTTP 標準庫發起請求、獲取響應時，即便你不從響應中讀取任何數據或響應爲空，都須要手動關閉響應體。新手很容易忘記手動關閉，或者寫在了錯誤的位置：

// 請求失敗形成 panic
func main() {
	resp, err := http.Get("https://api.ipify.org?format=json")
	defer resp.Body.Close()	// resp 可能爲 nil，不能讀取 Body
	if err != nil {
		fmt.Println(err)
		return
	}

	body, err := ioutil.ReadAll(resp.Body)
    checkError(err)

	fmt.Println(string(body))
}

func checkError(err error) {
	if err != nil{
		log.Fatalln(err)
	}
}

　　

上邊的代碼能正確發起請求，可是一旦請求失敗，變量 resp 值爲 nil，形成 panic：

panic: runtime error: invalid memory address or nil pointer dereference

應該先檢查 HTTP 響應錯誤爲 nil，再調用 resp.Body.Close() 來關閉響應體：

// 大多數狀況正確的示例
func main() {
	resp, err := http.Get("https://api.ipify.org?format=json")
	checkError(err)
    
	defer resp.Body.Close()	// 絕大多數狀況下的正確關閉方式
	body, err := ioutil.ReadAll(resp.Body)
	checkError(err)

	fmt.Println(string(body))
}

　　

輸出：

Get https://api.ipify.org?format=json: x509: certificate signed by unknown authority

絕大多數請求失敗的狀況下，resp 的值爲 nil 且 err 爲 non-nil。但若是你獲得的是重定向錯誤，那它倆的值都是 non-nil，最後依舊可能發生內存泄露。2 個解決辦法：

• 能夠直接在處理 HTTP 響應錯誤的代碼塊中，直接關閉非 nil 的響應體。
• 手動調用 defer 來關閉響應體：

// 正確示例
func main() {
    resp, err := http.Get("http://www.baidu.com")
    
    // 關閉 resp.Body 的正確姿式
    if resp != nil {
        defer resp.Body.Close()
    }

    checkError(err)

    body, err := ioutil.ReadAll(resp.Body)
    checkError(err)

    fmt.Println(string(body))
}

resp.Body.Close() 早先版本的實現是讀取響應體的數據以後丟棄，保證了 keep-alive 的 HTTP 鏈接能重用處理不止一個請求。但 Go 的最新版本將讀取並丟棄數據的任務交給了用戶，若是你不處理，HTTP 鏈接可能會直接關閉而非重用，參考在 Go 1.5 版本文檔。

若是程序大量重用 HTTP 長鏈接，你可能要在處理響應的邏輯代碼中加入：

_, err = io.Copy(ioutil.Discard, resp.Body)	// 手動丟棄讀取完畢的數據

　　若是你須要完整讀取響應，上邊的代碼是須要寫的。好比在解碼 API 的 JSON 響應數據：

json.NewDecoder(resp.Body).Decode(&data)

　　

36. 關閉 HTTP 鏈接

一些支持 HTTP1.1 或 HTTP1.0 配置了 connection: keep-alive 選項的服務器會保持一段時間的長鏈接。但標準庫 「net/http」 的鏈接默認只在服務器主動要求關閉時才斷開，因此你的程序可能會消耗完 socket 描述符。解決辦法有 2 個，請求結束後：

• 直接設置請求變量的 Close 字段值爲 true，每次請求結束後就會主動關閉鏈接。
• 設置 Header 請求頭部選項 Connection: close，而後服務器返回的響應頭部也會有這個選項，此時 HTTP 標準庫會主動斷開鏈接。

// 主動關閉鏈接
func main() {
    req, err := http.NewRequest("GET", "http://golang.org", nil)
    checkError(err)

    req.Close = true
    //req.Header.Add("Connection", "close")    // 等效的關閉方式

    resp, err := http.DefaultClient.Do(req)
    if resp != nil {
        defer resp.Body.Close()
    }
    checkError(err)

    body, err := ioutil.ReadAll(resp.Body)
    checkError(err)

    fmt.Println(string(body))
}

你能夠建立一個自定義配置的 HTTP transport 客戶端，用來取消 HTTP 全局的複用鏈接：

func main() {
    tr := http.Transport{DisableKeepAlives: true}
    client := http.Client{Transport: &tr}

    resp, err := client.Get("https://golang.google.cn/")
    if resp != nil {
        defer resp.Body.Close()
    }
    checkError(err)

    fmt.Println(resp.StatusCode)    // 200

    body, err := ioutil.ReadAll(resp.Body)
    checkError(err)

    fmt.Println(len(string(body)))
}

根據需求選擇使用場景：

• 若你的程序要向同一服務器發大量請求，使用默認的保持長鏈接。

• 若你的程序要鏈接大量的服務器，且每臺服務器只請求一兩次，那收到請求後直接關閉鏈接。或增長最大文件打開數 fs.file-max 的值。

37. 將 JSON 中的數字解碼爲 interface 類型

在 encode/decode JSON 數據時，Go 默認會將數值當作 float64 處理，好比下邊的代碼會形成 panic：

func main() {
    var data = []byte(`{"status": 200}`)
    var result map[string]interface{}

    if err := json.Unmarshal(data, &result); err != nil {
        log.Fatalln(err)
    }

    fmt.Printf("%T\n", result["status"])    // float64
    var status = result["status"].(int)    // 類型斷言錯誤
    fmt.Println("Status value: ", status)
}

panic: interface conversion: interface {} is float64, not int

若是你嘗試 decode 的 JSON 字段是整型，你能夠：

• 將 int 值轉爲 float 統一使用

• 將 decode 後須要的 float 值轉爲 int 使用

// 將 decode 的值轉爲 int 使用
func main() {
    var data = []byte(`{"status": 200}`)
    var result map[string]interface{}

    if err := json.Unmarshal(data, &result); err != nil {
        log.Fatalln(err)
    }

    var status = uint64(result["status"].(float64))
    fmt.Println("Status value: ", status)
}

　　使用 Decoder 類型來 decode JSON 數據，明確表示字段的值類型

// 指定字段類型
func main() {
    var data = []byte(`{"status": 200}`)
    var result map[string]interface{}
    
    var decoder = json.NewDecoder(bytes.NewReader(data))
    decoder.UseNumber()

    if err := decoder.Decode(&result); err != nil {
        log.Fatalln(err)
    }

    var status, _ = result["status"].(json.Number).Int64()
    fmt.Println("Status value: ", status)
}

 // 你可使用 string 來存儲數值數據，在 decode 時再決定按 int 仍是 float 使用
 // 將數據轉爲 decode 爲 string
 func main() {
     var data = []byte({"status": 200})
      var result map[string]interface{}
      var decoder = json.NewDecoder(bytes.NewReader(data))
      decoder.UseNumber()
      if err := decoder.Decode(&result); err != nil {
          log.Fatalln(err)
      }
    var status uint64
      err := json.Unmarshal([]byte(result["status"].(json.Number).String()), &status);
    checkError(err)
       fmt.Println("Status value: ", status)
}

- 使用 struct 類型將你須要的數據映射爲數值型

// struct 中指定字段類型
func main() {
      var data = []byte(`{"status": 200}`)
      var result struct {
          Status uint64 `json:"status"`
      }

      err := json.NewDecoder(bytes.NewReader(data)).Decode(&result)
      checkError(err)
    fmt.Printf("Result: %+v", result)
}

可使用 struct 將數值類型映射爲 json.RawMessage 原生數據類型

適用於若是 JSON 數據不着急 decode 或 JSON 某個字段的值類型不固定等狀況：

// 狀態名稱多是 int 也多是 string，指定爲 json.RawMessage 類型
func main() {
    records := [][]byte{
        []byte(`{"status":200, "tag":"one"}`),
        []byte(`{"status":"ok", "tag":"two"}`),
    }

    for idx, record := range records {
        var result struct {
            StatusCode uint64
            StatusName string
            Status     json.RawMessage `json:"status"`
            Tag        string          `json:"tag"`
        }

        err := json.NewDecoder(bytes.NewReader(record)).Decode(&result)
        checkError(err)

        var name string
        err = json.Unmarshal(result.Status, &name)
        if err == nil {
            result.StatusName = name
        }

        var code uint64
        err = json.Unmarshal(result.Status, &code)
        if err == nil {
            result.StatusCode = code
        }

        fmt.Printf("[%v] result => %+v\n", idx, result)
    }
}
​

38. struct、array、slice 和 map 的值比較

可使用相等運算符 == 來比較結構體變量，前提是兩個結構體的成員都是可比較的類型：

type data struct {
	num     int
	fp      float32
	complex complex64
	str     string
	char    rune
	yes     bool
	events  <-chan string
	handler interface{}
	ref     *byte
	raw     [10]byte
}

func main() {
	v1 := data{}
	v2 := data{}
	fmt.Println("v1 == v2: ", v1 == v2)	// true
}

　　若是兩個結構體中有任意成員是不可比較的，將會形成編譯錯誤。注意數組成員只有在數組元素可比較時候纔可比較。

type data struct {
	num    int
	checks [10]func() bool		// 沒法比較
	doIt   func() bool		// 沒法比較
	m      map[string]string	// 沒法比較
	bytes  []byte			// 沒法比較
}

func main() {
	v1 := data{}
	v2 := data{}

	fmt.Println("v1 == v2: ", v1 == v2)
}

　　

invalid operation: v1 == v2 (struct containing [10]func() bool cannot be compared)

Go 提供了一些庫函數來比較那些沒法使用 == 比較的變量，好比使用 「reflect」 包的 DeepEqual() ：

// 比較相等運算符沒法比較的元素
func main() {
	v1 := data{}
	v2 := data{}
	fmt.Println("v1 == v2: ", reflect.DeepEqual(v1, v2))	// true

	m1 := map[string]string{"one": "a", "two": "b"}
	m2 := map[string]string{"two": "b", "one": "a"}
	fmt.Println("v1 == v2: ", reflect.DeepEqual(m1, m2))	// true

	s1 := []int{1, 2, 3}
	s2 := []int{1, 2, 3}
   	// 注意兩個 slice 相等，值和順序必須一致
	fmt.Println("v1 == v2: ", reflect.DeepEqual(s1, s2))	// true
}

　　這種比較方式可能比較慢，根據你的程序需求來使用。DeepEqual() 還有其餘用法：

func main() {
	var b1 []byte = nil
	b2 := []byte{}
	fmt.Println("b1 == b2: ", reflect.DeepEqual(b1, b2))	// false
}

　　

注意：

• DeepEqual() 並不總適合於比較 slice

func main() {
	var str = "one"
	var in interface{} = "one"
	fmt.Println("str == in: ", reflect.DeepEqual(str, in))	// true

	v1 := []string{"one", "two"}
	v2 := []string{"two", "one"}
	fmt.Println("v1 == v2: ", reflect.DeepEqual(v1, v2))	// false

	data := map[string]interface{}{
		"code":  200,
		"value": []string{"one", "two"},
	}
	encoded, _ := json.Marshal(data)
	var decoded map[string]interface{}
	json.Unmarshal(encoded, &decoded)
	fmt.Println("data == decoded: ", reflect.DeepEqual(data, decoded))	// false
}

　　

若是要大小寫不敏感來比較 byte 或 string 中的英文文本，可使用 「bytes」 或 「strings」 包的 ToUpper() 和 ToLower() 函數。比較其餘語言的 byte 或 string，應使用 bytes.EqualFold() 和 strings.EqualFold()

若是 byte slice 中含有驗證用戶身份的數據（密文哈希、token 等），不該再使用 reflect.DeepEqual()、bytes.Equal()、 bytes.Compare()。這三個函數容易對程序形成 timing attacks，此時應使用 「crypto/subtle」 包中的 subtle.ConstantTimeCompare() 等函數

• reflect.DeepEqual() 認爲空 slice 與 nil slice 並不相等，但注意 byte.Equal() 會認爲兩者相等：

func main() {
	var b1 []byte = nil
	b2 := []byte{}

    // b1 與 b2 長度相等、有相同的字節序
    // nil 與 slice 在字節上是相同的
    fmt.Println("b1 == b2: ", bytes.Equal(b1, b2))	// true
}

　　

39. 從 panic 中恢復

在一個 defer 延遲執行的函數中調用 recover() ，它便能捕捉 / 中斷 panic

// 錯誤的 recover 調用示例
func main() {
	recover()	// 什麼都不會捕捉
	panic("not good")	// 發生 panic，主程序退出
	recover()	// 不會被執行
	println("ok")
}

// 正確的 recover 調用示例
func main() {
	defer func() {
		fmt.Println("recovered: ", recover())
	}()
	panic("not good")
}

　　從上邊能夠看出，recover() 僅在 defer 執行的函數中調用纔會生效。

// 錯誤的調用示例
func main() {
	defer func() {
		doRecover()
	}()
	panic("not good")
}

func doRecover() {
	fmt.Println("recobered: ", recover())
}

　　

recobered: panic: not good

40. 在 range 迭代 slice、array、map 時經過更新引用來更新元素
在 range 迭代中，獲得的值實際上是元素的一份值拷貝，更新拷貝並不會更改原來的元素，便是拷貝的地址並非原有元素的地址：

　　

func main() {
	data := []int{1, 2, 3}
	for _, v := range data {
		v *= 10		// data 中原有元素是不會被修改的
	}
	fmt.Println("data: ", data)	// data:  [1 2 3]
}

　　若是要修改原有元素的值，應該使用索引直接訪問：

func main() {
	data := []int{1, 2, 3}
	for i, v := range data {
		data[i] = v * 10	
	}
	fmt.Println("data: ", data)	// data:  [10 20 30]
}

　　若是你的集合保存的是指向值的指針，需稍做修改。依舊須要使用索引訪問元素，不過可使用 range 出來的元素直接更新原有值：

func main() {
	data := []*struct{ num int }{{1}, {2}, {3},}
	for _, v := range data {
		v.num *= 10	// 直接使用指針更新
	}
	fmt.Println(data[0], data[1], data[2])	// &{10} &{20} &{30}
}

　　

41. slice 中隱藏的數據

從 slice 中從新切出新 slice 時，新 slice 會引用原 slice 的底層數組。若是跳了這個坑，程序可能會分配大量的臨時 slice 來指向原底層數組的部分數據，將致使難以預料的內存使用。

func get() []byte {
	raw := make([]byte, 10000)
	fmt.Println(len(raw), cap(raw), &raw[0])	// 10000 10000 0xc420080000
	return raw[:3]	// 從新分配容量爲 10000 的 slice
}

func main() {
	data := get()
	fmt.Println(len(data), cap(data), &data[0])	// 3 10000 0xc420080000
}

　　能夠經過拷貝臨時 slice 的數據，而不是從新切片來解決：

func get() (res []byte) {
	raw := make([]byte, 10000)
	fmt.Println(len(raw), cap(raw), &raw[0])	// 10000 10000 0xc420080000
	res = make([]byte, 3)
	copy(res, raw[:3])
	return
}

func main() {
	data := get()
	fmt.Println(len(data), cap(data), &data[0])	// 3 3 0xc4200160b8
}

　　

42. Slice 中數據的誤用

舉個簡單例子，重寫文件路徑（存儲在 slice 中）

分割路徑來指向每一個不一樣級的目錄，修改第一個目錄名再重組子目錄名，建立新路徑：

// 錯誤使用 slice 的拼接示例
func main() {
	path := []byte("AAAA/BBBBBBBBB")
	sepIndex := bytes.IndexByte(path, '/') // 4
	println(sepIndex)

	dir1 := path[:sepIndex]
	dir2 := path[sepIndex+1:]
	println("dir1: ", string(dir1))		// AAAA
	println("dir2: ", string(dir2))		// BBBBBBBBB

	dir1 = append(dir1, "suffix"...)
   	println("current path: ", string(path))	// AAAAsuffixBBBB
    
	path = bytes.Join([][]byte{dir1, dir2}, []byte{'/'})
	println("dir1: ", string(dir1))		// AAAAsuffix
	println("dir2: ", string(dir2))		// uffixBBBB

	println("new path: ", string(path))	// AAAAsuffix/uffixBBBB	// 錯誤結果
}

　　

拼接的結果不是正確的 AAAAsuffix/BBBBBBBBB，由於 dir一、 dir2 兩個 slice 引用的數據都是 path 的底層數組，第 13 行修改 dir1 同時也修改了 path，也致使了 dir2 的修改

解決方法：

從新分配新的 slice 並拷貝你須要的數據
使用完整的 slice 表達式：input[low:high:max]，容量便調整爲 max - low

　　

// 使用 full slice expression
func main() {

	path := []byte("AAAA/BBBBBBBBB")
	sepIndex := bytes.IndexByte(path, '/') // 4
    dir1 := path[:sepIndex:sepIndex]		// 此時 cap(dir1) 指定爲4， 而不是先前的 16
	dir2 := path[sepIndex+1:]
	dir1 = append(dir1, "suffix"...)

	path = bytes.Join([][]byte{dir1, dir2}, []byte{'/'})
	println("dir1: ", string(dir1))		// AAAAsuffix
	println("dir2: ", string(dir2))		// BBBBBBBBB
	println("new path: ", string(path))	// AAAAsuffix/BBBBBBBBB
}

　　

第 6 行中第三個參數是用來控制 dir1 的新容量，再往 dir1 中 append 超額元素時，將分配新的 buffer 來保存。而不是覆蓋原來的 path 底層數組

43. 舊 slice

當你從一個已存在的 slice 建立新 slice 時，兩者的數據指向相同的底層數組。若是你的程序使用這個特性，那須要注意 「舊」（stale） slice 問題。

某些狀況下，向一個 slice 中追加元素而它指向的底層數組容量不足時，將會從新分配一個新數組來存儲數據。而其餘 slice 還指向原來的舊底層數組。

// 超過容量將從新分配數組來拷貝值、從新存儲
func main() {
	s1 := []int{1, 2, 3}
	fmt.Println(len(s1), cap(s1), s1)	// 3 3 [1 2 3 ]

	s2 := s1[1:]
	fmt.Println(len(s2), cap(s2), s2)	// 2 2 [2 3]

	for i := range s2 {
		s2[i] += 20
	}
	// 此時的 s1 與 s2 是指向同一個底層數組的
	fmt.Println(s1)		// [1 22 23]
	fmt.Println(s2)		// [22 23]

	s2 = append(s2, 4)	// 向容量爲 2 的 s2 中再追加元素，此時將分配新數組來存

	for i := range s2 {
		s2[i] += 10
	}
	fmt.Println(s1)		// [1 22 23]	// 此時的 s1 再也不更新，爲舊數據
	fmt.Println(s2)		// [32 33 14]
}

　　

44. 類型聲明與方法

從一個現有的非 interface 類型建立新類型時，並不會繼承原有的方法：

// 定義 Mutex 的自定義類型
type myMutex sync.Mutex

func main() {
	var mtx myMutex
	mtx.Lock()
	mtx.UnLock()
}

　　

mtx.Lock undefined (type myMutex has no field or method Lock)…

若是你須要使用原類型的方法，可將原類型以匿名字段的形式嵌到你定義的新 struct 中：

// 類型以字段形式直接嵌入
type myLocker struct {
	sync.Mutex
}

func main() {
	var locker myLocker
	locker.Lock()
	locker.Unlock()
}

　　interface 類型聲明也保留它的方法集：

type myLocker sync.Locker

func main() {
	var locker myLocker
	locker.Lock()
	locker.Unlock()
}

　　

45. 跳出 for-switch 和 for-select 代碼塊

沒有指定標籤的 break 只會跳出 switch/select 語句，若不能使用 return 語句跳出的話，可爲 break 跳出標籤指定的代碼塊：

// break 配合 label 跳出指定代碼塊
func main() {
loop:
	for {
		switch {
		case true:
			fmt.Println("breaking out...")
			//break	// 死循環，一直打印 breaking out...
			break loop
		}
	}
	fmt.Println("out...")
}

　　

goto 雖然也能跳轉到指定位置，但依舊會再次進入 for-switch，死循環。

46. for 語句中的迭代變量與閉包函數

for 語句中的迭代變量在每次迭代中都會重用，即 for 中建立的閉包函數接收到的參數始終是同一個變量，在 goroutine 開始執行時都會獲得同一個迭代值：

func main() {
	data := []string{"one", "two", "three"}

	for _, v := range data {
		go func() {
			fmt.Println(v)
		}()
	}

	time.Sleep(3 * time.Second)
	// 輸出 three three three
}

　　最簡單的解決方法：無需修改 goroutine 函數，在 for 內部使用局部變量保存迭代值，再傳參：

func main() {
	data := []string{"one", "two", "three"}

	for _, v := range data {
		vCopy := v
		go func() {
			fmt.Println(vCopy)
		}()
	}

	time.Sleep(3 * time.Second)
	// 輸出 one two three
}

　　另外一個解決方法：直接將當前的迭代值以參數形式傳遞給匿名函數：

func main() {
	data := []string{"one", "two", "three"}

	for _, v := range data {
		go func(in string) {
			fmt.Println(in)
		}(v)
	}

	time.Sleep(3 * time.Second)
	// 輸出 one two three
}

　　注意下邊這個稍複雜的 3 個示例區別：

type field struct {
	name string
}

func (p *field) print() {
	fmt.Println(p.name)
}

// 錯誤示例
func main() {
	data := []field{{"one"}, {"two"}, {"three"}}
	for _, v := range data {
		go v.print()
	}
	time.Sleep(3 * time.Second)
	// 輸出 three three three 
}


// 正確示例
func main() {
	data := []field{{"one"}, {"two"}, {"three"}}
	for _, v := range data {
		v := v
		go v.print()
	}
	time.Sleep(3 * time.Second)
	// 輸出 one two three
}

// 正確示例
func main() {
	data := []*field{{"one"}, {"two"}, {"three"}}
	for _, v := range data {	// 此時迭代值 v 是三個元素值的地址，每次 v 指向的值不一樣
		go v.print()
	}
	time.Sleep(3 * time.Second)
	// 輸出 one two three
}

　　

47. defer 函數的參數值

對 defer 延遲執行的函數，它的參數會在聲明時候就會求出具體值，而不是在執行時才求值：

// 在 defer 函數中參數會提早求值
func main() {
	var i = 1
	defer fmt.Println("result: ", func() int { return i * 2 }())
	i++
}

　　

result: 2

48. defer 函數的執行時機

對 defer 延遲執行的函數，會在調用它的函數結束時執行，而不是在調用它的語句塊結束時執行，注意區分開。

好比在一個長時間執行的函數裏，內部 for 循環中使用 defer 來清理每次迭代產生的資源調用，就會出現問題：

 

// 命令行參數指定目錄名
// 遍歷讀取目錄下的文件
func main() {

	if len(os.Args) != 2 {
		os.Exit(1)
	}

	dir := os.Args[1]
	start, err := os.Stat(dir)
	if err != nil || !start.IsDir() {
		os.Exit(2)
	}

	var targets []string
	filepath.Walk(dir, func(fPath string, fInfo os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if !fInfo.Mode().IsRegular() {
			return nil
		}

		targets = append(targets, fPath)
		return nil
	})

	for _, target := range targets {
		f, err := os.Open(target)
		if err != nil {
			fmt.Println("bad target:", target, "error:", err)	//error:too many open files
			break
		}
		defer f.Close()	// 在每次 for 語句塊結束時，不會關閉文件資源
		
		// 使用 f 資源
	}
}

　　先建立 10000 個文件：

#!/bin/bash
for n in {1..10000}; do
	echo content > "file${n}.txt"
done

　　

運行效果：

解決辦法：defer 延遲執行的函數寫入匿名函數中：

// 目錄遍歷正常
func main() {
    // ...

	for _, target := range targets {
		func() {
			f, err := os.Open(target)
			if err != nil {
				fmt.Println("bad target:", target, "error:", err)
				return	// 在匿名函數內使用 return 代替 break 便可
			}
			defer f.Close()	// 匿名函數執行結束，調用關閉文件資源
			
			// 使用 f 資源
		}()
	}
}

　　

固然你也能夠去掉 defer，在文件資源使用完畢後，直接調用 f.Close() 來關閉。

49. 失敗的類型斷言

在類型斷言語句中，斷言失敗則會返回目標類型的「零值」，斷言變量與原來變量混用可能出現異常狀況：

// 錯誤示例
func main() {
	var data interface{} = "great"

    // data 混用
	if data, ok := data.(int); ok {
		fmt.Println("[is an int], data: ", data)
	} else {
		fmt.Println("[not an int], data: ", data)	// [isn't a int], data:  0
	}
}


// 正確示例
func main() {
	var data interface{} = "great"

	if res, ok := data.(int); ok {
		fmt.Println("[is an int], data: ", res)
	} else {
		fmt.Println("[not an int], data: ", data)	// [not an int], data:  great
	}
}

　　

50. 阻塞的 gorutinue 與資源泄露

在 2012 年 Google I/O 大會上，Rob Pike 的 Go Concurrency Patterns 演講討論 Go 的幾種基本併發模式，如 完整代碼 中從數據集中獲取第一條數據的函數：

func First(query string, replicas []Search) Result {
	c := make(chan Result)
	replicaSearch := func(i int) { c <- replicas[i](query) }
	for i := range replicas {
		go replicaSearch(i)
	}
	return <-c
}

　　

在搜索重複時依舊每次都起一個 goroutine 去處理，每一個 goroutine 都把它的搜索結果發送到結果 channel 中，channel 中收到的第一條數據會直接返回。

返回完第一條數據後，其餘 goroutine 的搜索結果怎麼處理？他們本身的協程如何處理？

在 First() 中的結果 channel 是無緩衝的，這意味着只有第一個 goroutine 能返回，因爲沒有 receiver，其餘的 goroutine 會在發送上一直阻塞。若是你大量調用，則可能形成資源泄露。

爲避免泄露，你應該確保全部的 goroutine 都能正確退出，有 2 個解決方法：

• 使用帶緩衝的 channel，確保能接收所有 goroutine 的返回結果：

func First(query string, replicas ...Search) Result {  
    c := make(chan Result,len(replicas))	
    searchReplica := func(i int) { c <- replicas[i](query) }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

　　

使用 select 語句，配合能保存一個緩衝值的 channel default 語句：

default 的緩衝 channel 保證了即便結果 channel 收不到數據，也不會阻塞 goroutine

func First(query string, replicas ...Search) Result {  
    c := make(chan Result,1)
    searchReplica := func(i int) { 
        select {
        case c <- replicas[i](query):
        default:
        }
    }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

　　使用特殊的廢棄（cancellation） channel 來中斷剩餘 goroutine 的執行：

func First(query string, replicas ...Search) Result {  
    c := make(chan Result)
    done := make(chan struct{})
    defer close(done)
    searchReplica := func(i int) { 
        select {
        case c <- replicas[i](query):
        case <- done:
        }
    }
    for i := range replicas {
        go searchReplica(i)
    }

    return <-c
}

　　

Rob Pike 爲了簡化演示，沒有說起演講代碼中存在的這些問題。不過對於新手來講，可能會不加思考直接使用。

高級篇：51-57

51. 使用指針做爲方法的 receiver

只要值是可尋址的，就能夠在值上直接調用指針方法。便是對一個方法，它的 receiver 是指針就足矣。

但不是全部值都是可尋址的，好比 map 類型的元素、經過 interface 引用的變量：

type data struct {
	name string
}

type printer interface {
	print()
}

func (p *data) print() {
	fmt.Println("name: ", p.name)
}

func main() {
	d1 := data{"one"}
	d1.print()	// d1 變量可尋址，可直接調用指針 receiver 的方法

	var in printer = data{"two"}
	in.print()	// 類型不匹配

	m := map[string]data{
		"x": data{"three"},
	}
	m["x"].print()	// m["x"] 是不可尋址的	// 變更頻繁
}

　　

cannot use data literal (type data) as type printer in assignment:

data does not implement printer (print method has pointer receiver)

cannot call pointer method on m[「x」]
cannot take the address of m[「x」]

52. 更新 map 字段的值

若是 map 一個字段的值是 struct 類型，則沒法直接更新該 struct 的單個字段：

// 沒法直接更新 struct 的字段值
type data struct {
	name string
}

func main() {
	m := map[string]data{
		"x": {"Tom"},
	}
	m["x"].name = "Jerry"
}

　　

cannot assign to struct field m[「x」].name in map

由於 map 中的元素是不可尋址的。需區分開的是，slice 的元素可尋址：

type data struct {
	name string
}

func main() {
	s := []data{{"Tom"}}
	s[0].name = "Jerry"
	fmt.Println(s)	// [{Jerry}]
}

　　

注意：不久前 gccgo 編譯器可更新 map struct 元素的字段值，不過很快便修復了，官方認爲是 Go1.3 的潛在特性，無需及時實現，依舊在 todo list 中。

更新 map 中 struct 元素的字段值，有 2 個方法：

• 使用局部變量

• // 提取整個 struct 到局部變量中，修改字段值後再整個賦值
  type data struct {
  	name string
  }
  
  func main() {
  	m := map[string]data{
  		"x": {"Tom"},
  	}
  	r := m["x"]
  	r.name = "Jerry"
  	m["x"] = r
  	fmt.Println(m)	// map[x:{Jerry}]
  }
  

  　　使用指向元素的 map 指針

• func main() {
  	m := map[string]*data{
  		"x": {"Tom"},
  	}
  	
  	m["x"].name = "Jerry"	// 直接修改 m["x"] 中的字段
  	fmt.Println(m["x"])	// &{Jerry}
  }
  

  　　可是要注意下邊這種誤用：

• func main() {
  	m := map[string]*data{
  		"x": {"Tom"},
  	}
  	m["z"].name = "what???"	 
  	fmt.Println(m["x"])
  }
  

  　　

  panic: runtime error: invalid memory address or nil pointer dereference

  53. nil interface 和 nil interface 值

  雖然 interface 看起來像指針類型，但它不是。interface 類型的變量只有在類型和值均爲 nil 時才爲 nil

  若是你的 interface 變量的值是跟隨其餘變量變化的（霧），與 nil 比較相等時當心：

• func main() {
  	var data *byte
  	var in interface{}
  
  	fmt.Println(data, data == nil)	// <nil> true
  	fmt.Println(in, in == nil)	// <nil> true
  
  	in = data
  	fmt.Println(in, in == nil)	// <nil> false	// data 值爲 nil，但 in 值不爲 nil
  }
  

  　　若是你的函數返回值類型是 interface，更要當心這個坑：

• // 錯誤示例
  func main() {
  	doIt := func(arg int) interface{} {
  		var result *struct{} = nil
  		if arg > 0 {
  			result = &struct{}{}
  		}
  		return result
  	}
  
  	if res := doIt(-1); res != nil {
  		fmt.Println("Good result: ", res)	// Good result:  <nil>
  		fmt.Printf("%T\n", res)			// *struct {}	// res 不是 nil，它的值爲 nil
  		fmt.Printf("%v\n", res)			// <nil>
  	}
  }
  
  
  // 正確示例
  func main() {
  	doIt := func(arg int) interface{} {
  		var result *struct{} = nil
  		if arg > 0 {
  			result = &struct{}{}
  		} else {
  			return nil	// 明確指明返回 nil
  		}
  		return result
  	}
  
  	if res := doIt(-1); res != nil {
  		fmt.Println("Good result: ", res)
  	} else {
  		fmt.Println("Bad result: ", res)	// Bad result:  <nil>
  	}
  }