Go的50坑：新Golang開發者要注意的陷阱、技巧和常見錯誤[2]

Golang做爲一個略古怪而新的語言，有本身一套特點和哲學。從其餘語言轉來的開發者在剛接觸到的時候每每大吃苦頭，我也不例外。這篇文章很細緻地介紹了Golang的一些常見坑點，讀徹底篇中槍好屢次。故將其轉載。因爲文章很長，分爲上下兩部分，第一部分記錄初級篇，第二部分記錄進階和高級篇：此爲第二部分javascript

初級篇java
開大括號不能放在單獨的一行golang
未使用的變量express
未使用的Importsjson
簡式的變量聲明僅能夠在函數內部使用api
使用簡式聲明重複聲明變量數組
偶然的變量隱藏Accidental Variable Shadowing緩存
不使用顯式類型，沒法使用「nil」來初始化變量服務器
使用「nil」 Slices and Maps網絡
Map的容量
字符串不會爲「nil」
Array函數的參數
在Slice和Array使用「range」語句時的出現的不但願獲得的值
Slices和Arrays是一維的
訪問不存在的Map Keys
Strings沒法修改
String和Byte Slice之間的轉換
String和索引操做
字符串不老是UTF8文本
字符串的長度
在多行的Slice、Array和Map語句中遺漏逗號
log.Fatal和log.Panic不只僅是Log
內建的數據結構操做不是同步的
String在「range」語句中的迭代值
對Map使用「for range」語句迭代
"switch"聲明中的失效行爲
自增和自減
按位NOT操做
操做優先級的差別
未導出的結構體不會被編碼
有活動的Goroutines下的應用退出
向無緩存的Channel發送消息，只要目標接收者準備好就會當即返回
向已關閉的Channel發送會引發Panic
使用"nil" Channels
傳值方法的接收者沒法修改原有的值
進階篇
關閉HTTP的響應
關閉HTTP的鏈接
比較Structs, Arrays, Slices, and Maps
從Panic中恢復
在Slice, Array, and Map "range"語句中更新引用元素的值
在Slice中"隱藏"數據
Slice的數據「毀壞」
"走味的"Slices
類型聲明和方法
從"for switch"和"for select"代碼塊中跳出
"for"聲明中的迭代變量和閉包
Defer函數調用參數的求值
被Defer的函數調用執行
失敗的類型斷言
阻塞的Goroutine和資源泄露
高級篇
使用指針接收方法的值的實例
更新Map的值
"nil" Interfaces和"nil" Interfaces的值
棧和堆變量
GOMAXPROCS, 併發, 和並行
讀寫操做的重排順序
優先調度

進階篇

關閉HTTP的響應

level: intermediate

當你使用標準http庫發起請求時，你獲得一個http的響應變量。若是你不讀取響應主體，你依舊須要關閉它。注意對於空的響應你也必定要這麼作。對於新的Go開發者而言，這個很容易就會忘掉。

一些新的Go開發者確實嘗試關閉響應主體，但他們在錯誤的地方作。

package main

import("fmt""net/http""io/ioutil")

func main(){  
    resp, err := http.Get("https://api.ipify.org?format=json")
    defer resp.Body.Close()//not okif err !=nil{
        fmt.Println(err)return}

    body, err := ioutil.ReadAll(resp.Body)if err !=nil{
        fmt.Println(err)return}

    fmt.Println(string(body))}

這段代碼對於成功的請求沒問題，但若是http的請求失敗， resp變量可能會是 nil，這將致使一個runtime panic。

最多見的關閉響應主體的方法是在http響應的錯誤檢查後調用 defer。

package main

import("fmt""net/http""io/ioutil")

func main(){  
    resp, err := http.Get("https://api.ipify.org?format=json")if err !=nil{
        fmt.Println(err)return}

    defer resp.Body.Close()//ok, most of the time :-)
    body, err := ioutil.ReadAll(resp.Body)if err !=nil{
        fmt.Println(err)return}

    fmt.Println(string(body))}

大多數狀況下，當你的http響應失敗時， resp變量將爲 nil，而 err變量將是 non-nil。然而，當你獲得一個重定向的錯誤時，兩個變量都將是 non-nil。這意味着你最後依然會內存泄露。

經過在http響應錯誤處理中添加一個關閉 non-nil響應主體的的調用來修復這個問題。另外一個方法是使用一個 defer調用來關閉全部失敗和成功的請求的響應主體。

package main

import("fmt""net/http""io/ioutil")

func main(){  
    resp, err := http.Get("https://api.ipify.org?format=json")if resp !=nil{
        defer resp.Body.Close()}if err !=nil{
        fmt.Println(err)return}

    body, err := ioutil.ReadAll(resp.Body)if err !=nil{
        fmt.Println(err)return}

    fmt.Println(string(body))}

resp.Body.Close()的原始實現也會讀取並丟棄剩餘的響應主體數據。這確保了http的連接在keepalive http鏈接行爲開啓的狀況下，能夠被另外一個請求複用。最新的http客戶端的行爲是不一樣的。如今讀取並丟棄剩餘的響應數據是你的職責。若是你不這麼作，http的鏈接可能會關閉，而沒法被重用。這個小技巧應該會寫在Go 1.5的文檔中。

若是http鏈接的重用對你的應用很重要，你可能須要在響應處理邏輯的後面添加像下面的代碼：

_, err = io.Copy(ioutil.Discard, resp.Body)

若是你不當即讀取整個響應將是必要的，這可能在你處理json API響應時會發生：

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

關閉HTTP的鏈接

level: intermediate

一些HTTP服務器保持會保持一段時間的網絡鏈接（根據HTTP 1.1的說明和服務器端的「keep-alive」配置）。默認狀況下，標準http庫只在目標HTTP服務器要求關閉時纔會關閉網絡鏈接。這意味着你的應用在某些條件下消耗完sockets/file的描述符。

你能夠經過設置請求變量中的 Close域的值爲 true，來讓http庫在請求完成時關閉鏈接。

另外一個選項是添加一個 Connection的請求頭，並設置爲 close。目標HTTP服務器應該也會響應一個 Connection: close的頭。當http庫看到這個響應頭時，它也將會關閉鏈接。

package main

import("fmt""net/http""io/ioutil")

func main(){  
    req, err := http.NewRequest("GET","http://golang.org",nil)if err !=nil{
        fmt.Println(err)return}

    req.Close=true//or do this://req.Header.Add("Connection", "close")

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

    body, err := ioutil.ReadAll(resp.Body)if err !=nil{
        fmt.Println(err)return}

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

你也能夠取消http的全局鏈接複用。你將須要爲此建立一個自定義的http傳輸配置。

package main

import("fmt""net/http""io/ioutil")

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

    resp, err := client.Get("http://golang.org")if resp !=nil{
        defer resp.Body.Close()}if err !=nil{
        fmt.Println(err)return}

    fmt.Println(resp.StatusCode)

    body, err := ioutil.ReadAll(resp.Body)if err !=nil{
        fmt.Println(err)return}

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

若是你向同一個HTTP服務器發送大量的請求，那麼把保持網絡鏈接的打開是沒問題的。然而，若是你的應用在短期內向大量不一樣的HTTP服務器發送一兩個請求，那麼在引用收到響應後馬上關閉網絡鏈接是一個好主意。增長打開文件的限制數可能也是個好主意。固然，正確的選擇源自於應用。

比較Structs, Arrays, Slices, and Maps

level: intermediate

若是結構體中的各個元素均可以用你可使用等號來比較的話，那就可使用相號, ==，來比較結構體變量。

package main

import"fmt"

type data struct{  
    num int
    fp float32
    complex complex64
    str stringchar 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)//prints: v1 == v2: true}

若是結構體中的元素沒法比較，那使用等號將致使編譯錯誤。注意數組僅在它們的數據元素可比較的狀況下才能夠比較。

package main

import"fmt"

type data struct{  
    num int//ok
    checks [10]func()bool//not comparable
    doit func()bool//not comparable
    m map[string]string//not comparable
    bytes []byte//not comparable}

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

Go確實提供了一些助手函數，用於比較那些沒法使用等號比較的變量。

最經常使用的方法是使用 reflect包中的 DeepEqual()函數。

package main

import("fmt""reflect")

type data struct{  
    num int//ok
    checks [10]func()bool//not comparable
    doit func()bool//not comparable
    m map[string]string//not comparable
    bytes []byte//not comparable}

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

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

    s1 :=[]int{1,2,3}
    s2 :=[]int{1,2,3}
    fmt.Println("s1 == s2:",reflect.DeepEqual(s1, s2))//prints: s1 == s2: true}

除了很慢（這個可能會也可能不會影響你的應用）， DeepEqual()也有其餘自身的技巧。

package main

import("fmt""reflect")

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

DeepEqual()不會認爲空的slice與「nil」的slice相等。這個行爲與你使用 bytes.Equal()函數的行爲不一樣。 bytes.Equal()認爲「nil」和空的slice是相等的。

package main

import("fmt""bytes")

func main(){var b1 []byte=nil
    b2 :=[]byte{}
    fmt.Println("b1 == b2:",bytes.Equal(b1, b2))//prints: b1 == b2: true}

DeepEqual()在比較slice時並不老是完美的。

package main

import("fmt""reflect""encoding/json")

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

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

    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))//prints: data == decoded: false (not ok)}

若是你的byte slice（或者字符串）中包含文字數據，而當你要不區分大小寫形式的值時（在使用 ==， bytes.Equal()，或者 bytes.Compare()），你可能會嘗試使用「bytes」和「string」包中的 ToUpper()或者 ToLower()函數。對於英語文本，這麼作是沒問題的，但對於許多其餘的語言來講就不行了。這時應該使用 strings.EqualFold()和 bytes.EqualFold()。

若是你的byte slice中包含須要驗證用戶數據的隱私信息（好比，加密哈希、tokens等），不要使用 reflect.DeepEqual()、 bytes.Equal()，或者 bytes.Compare()，由於這些函數將會讓你的應用易於被定時攻擊。爲了不泄露時間信息，使用 'crypto/subtle'包中的函數（即， subtle.ConstantTimeCompare()）。

從Panic中恢復

level: intermediate

recover()函數能夠用於獲取/攔截panic。僅當在一個defer函數中被完成時，調用 recover()將會完成這個小技巧。

Incorrect:

ackage main

import"fmt"

func main(){  
    recover()//doesn't do anything
    panic("not good")
    recover()//won't be executed :)
    fmt.Println("ok")}

Works:

package main

import"fmt"

func main(){  
    defer func(){
        fmt.Println("recovered:",recover())}()

    panic("not good")}

recover()的調用僅當它在defer函數中被直接調用時纔有效。

Fails:

package main

import"fmt"

func doRecover(){  
    fmt.Println("recovered =>",recover())//prints: recovered => <nil>}

func main(){  
    defer func(){
        doRecover()//panic is not recovered}()

    panic("not good")}

在Slice, Array, and Map "range"語句中更新引用元素的值

level: intermediate

在「range」語句中生成的數據的值是真實集合元素的拷貝。它們不是原有元素的引用。這意味着更新這些值將不會修改原來的數據。同時也意味着使用這些值的地址將不會獲得原有數據的指針。

package main

import"fmt"

func main(){  
    data :=[]int{1,2,3}for _,v := range data {
        v *=10//original item is not changed}

    fmt.Println("data:",data)//prints data: [1 2 3]}

若是你須要更新原有集合中的數據，使用索引操做符來得到數據。

package main

import"fmt"

func main(){  
    data :=[]int{1,2,3}for i,_ := range data {
        data[i]*=10}

    fmt.Println("data:",data)//prints data: [10 20 30]}

若是你的集合保存的是指針，那規則會稍有不一樣。若是要更新原有記錄指向的數據，你依然須要使用索引操做，但你可使用 for range語句中的第二個值來更新存儲在目標位置的數據。

package main

import"fmt"

func main(){  
    data :=[]*struct{num int}{{1},{2},{3}}for _,v := range data {
        v.num *=10}

    fmt.Println(data[0],data[1],data[2])//prints &{10} &{20} &{30}}

在Slice中"隱藏"數據

level: intermediate

當你從新劃分一個slice時，新的slice將引用原有slice的數組。若是你忘了這個行爲的話，在你的應用分配大量臨時的slice用於建立新的slice來引用原有數據的一小部分時，會致使難以預期的內存使用。

package main

import"fmt"

func get()[]byte{  
    raw := make([]byte,10000)
    fmt.Println(len(raw),cap(raw),&raw[0])//prints: 10000 10000 <byte_addr_x>return raw[:3]}

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

爲了不這個陷阱，你須要從臨時的slice中拷貝數據（而不是從新劃分slice）。

package main

import"fmt"

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

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

Slice的數據「毀壞」

level: intermediate

好比說你須要從新一個路徑（在slice中保存）。你經過修改第一個文件夾的名字，而後把名字合併來建立新的路勁，來從新劃分指向各個文件夾的路徑。

package main

import("fmt""bytes")

func main(){  
    path :=[]byte("AAAA/BBBBBBBBB")
    sepIndex := bytes.IndexByte(path,'/')
    dir1 := path[:sepIndex]
    dir2 := path[sepIndex+1:]
    fmt.Println("dir1 =>",string(dir1))//prints: dir1 => AAAA
    fmt.Println("dir2 =>",string(dir2))//prints: dir2 => BBBBBBBBB

    dir1 = append(dir1,"suffix"...)
    path = bytes.Join([][]byte{dir1,dir2},[]byte{'/'})

    fmt.Println("dir1 =>",string(dir1))//prints: dir1 => AAAAsuffix
    fmt.Println("dir2 =>",string(dir2))//prints: dir2 => uffixBBBB (not ok)

    fmt.Println("new path =>",string(path))}

結果與你想的不同。與"AAAAsuffix/BBBBBBBBB"相反，你將會獲得"AAAAsuffix/uffixBBBB"。這個狀況的發生是由於兩個文件夾的slice都潛在的引用了同一個原始的路徑slice。這意味着原始路徑也被修改了。根據你的應用，這也許會是個問題。

經過分配新的slice並拷貝須要的數據，你能夠修復這個問題。另外一個選擇是使用完整的slice表達式。

package main

import("fmt""bytes")

func main(){  
    path :=[]byte("AAAA/BBBBBBBBB")
    sepIndex := bytes.IndexByte(path,'/')
    dir1 := path[:sepIndex:sepIndex]//full slice expression
    dir2 := path[sepIndex+1:]
    fmt.Println("dir1 =>",string(dir1))//prints: dir1 => AAAA
    fmt.Println("dir2 =>",string(dir2))//prints: dir2 => BBBBBBBBB

    dir1 = append(dir1,"suffix"...)
    path = bytes.Join([][]byte{dir1,dir2},[]byte{'/'})

    fmt.Println("dir1 =>",string(dir1))//prints: dir1 => AAAAsuffix
    fmt.Println("dir2 =>",string(dir2))//prints: dir2 => BBBBBBBBB (ok now)

    fmt.Println("new path =>",string(path))}

完整的slice表達式中的額外參數能夠控制新的slice的容量。如今在那個slice後添加元素將會觸發一個新的buffer分配，而不是覆蓋第二個slice中的數據。

"走味的"Slices

level: intermediate

多個slice能夠引用同一個數據。好比，當你從一個已有的slice建立一個新的slice時，這就會發生。若是你的應用功能須要這種行爲，那麼你將須要關注下「走味的」slice。

在某些狀況下，在一個slice中添加新的數據，在原有數組沒法保持更多新的數據時，將致使分配一個新的數組。而如今其餘的slice還指向老的數組（和老的數據）。

import"fmt"

func main(){  
    s1 :=[]int{1,2,3}
    fmt.Println(len(s1),cap(s1),s1)//prints 3 3 [1 2 3]

    s2 := s1[1:]
    fmt.Println(len(s2),cap(s2),s2)//prints 2 2 [2 3]for i := range s2 { s2[i]+=20}//still referencing the same array
    fmt.Println(s1)//prints [1 22 23]
    fmt.Println(s2)//prints [22 23]

    s2 = append(s2,4)for i := range s2 { s2[i]+=10}//s1 is now "stale"
    fmt.Println(s1)//prints [1 22 23]
    fmt.Println(s2)//prints [32 33 14]}

類型聲明和方法

level: intermediate

當你經過把一個現有（非interface）的類型定義爲一個新的類型時，新的類型不會繼承現有類型的方法。

Fails:

package main

import"sync"

type myMutex sync.Mutex

func main(){var mtx myMutex
    mtx.Lock()//error
    mtx.Unlock()//error  }

Compile Errors:

/tmp/sandbox106401185/main.go:9: mtx.Lockundefined(type myMutex has no field or method Lock)/tmp/sandbox106401185/main.go:10: mtx.Unlockundefined(type myMutex has no field or method Unlock)

若是你確實須要原有類型的方法，你能夠定義一個新的struct類型，用匿名方式把原有類型嵌入其中。

Works:

package main

import"sync"

type myLocker struct{  
    sync.Mutex}

func main(){varlock myLocker
    lock.Lock()//oklock.Unlock()//ok}

interface類型的聲明也會保留它們的方法集合。

Works:package main

import"sync"

type myLocker sync.Locker

func main(){varlock myLocker =new(sync.Mutex)lock.Lock()//oklock.Unlock()//ok}

從"for switch"和"for select"代碼塊中跳出

level: intermediate

沒有標籤的「break」聲明只能從內部的switch/select代碼塊中跳出來。若是沒法使用「return」聲明的話，那就爲外部循環定義一個標籤是另外一個好的選擇。

package main

import"fmt"

func main(){  
    loop:for{switch{casetrue:
                fmt.Println("breaking out...")break loop
            }}

    fmt.Println("out!")}

"goto"聲明也能夠完成這個功能。。。

"for"聲明中的迭代變量和閉包

level: intermediate

這在Go中是個很常見的技巧。 for語句中的迭代變量在每次迭代時被從新使用。這就意味着你在 for循環中建立的閉包（即函數字面量）將會引用同一個變量（而在那些goroutine開始執行時就會獲得那個變量的值）。

Incorrect:

package main

import("fmt""time")

func main(){  
    data :=[]string{"one","two","three"}for _,v := range data {
        go func(){
            fmt.Println(v)}()}

    time.Sleep(3* time.Second)//goroutines print: three, three, three}

最簡單的解決方法（不須要修改goroutine）是，在 for循環代碼塊內把當前迭代的變量值保存到一個局部變量中。

Works:

package main

import("fmt""time")

func main(){  
    data :=[]string{"one","two","three"}for _,v := range data {
        vcopy := v //
        go func(){
            fmt.Println(vcopy)}()}

    time.Sleep(3* time.Second)//goroutines print: one, two, three}

另外一個解決方法是把當前的迭代變量做爲匿名goroutine的參數。

Works:

package main

import("fmt""time")

func main(){  
    data :=[]string{"one","two","three"}for _,v := range data {
        go func(instring){
            fmt.Println(in)}(v)}

    time.Sleep(3* time.Second)//goroutines print: one, two, three}

下面這個陷阱稍微複雜一些的版本。

Incorrect:

package main

import("fmt""time")

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)//goroutines print: three, three, three}

Works:

package main

import("fmt""time")

type field struct{  
    name string}

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

func main(){  
    data :=[]field{{"one"},{"two"},{"three"}}for _,v := range data {
        v := v
        go v.print()}

    time.Sleep(3* time.Second)//goroutines print: one, two, three}

在運行這段代碼時你認爲會看到什麼結果？（緣由是什麼？）

package main

import("fmt""time")

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

Defer函數調用參數的求值

level: intermediate

被defer的函數的參數會在defer聲明時求值（而不是在函數實際執行時）。

Arguments for a deferred function call are evaluated when the defer statement is evaluated (not when the function is actually executing).

package main

import"fmt"

func main(){var i int=1

    defer fmt.Println("result =>",func()int{return i *2}())
    i++//prints: result => 2 (not ok if you expected 4)}

被Defer的函數調用執行

level: intermediate

被defer的調用會在包含的函數的末尾執行，而不是包含代碼塊的末尾。對於Go新手而言，一個很常犯的錯誤就是沒法區分被defer的代碼執行規則和變量做用規則。若是你有一個長時運行的函數，而函數內有一個 for循環試圖在每次迭代時都 defer資源清理調用，那就會出現問題。

package main

import("fmt""os""path/filepath")

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

    start, err := os.Stat(os.Args[1])if err !=nil||!start.IsDir(){
        os.Exit(-1)}var targets []string
    filepath.Walk(os.Args[1], func(fpath string,fi os.FileInfo, err error) error {if err !=nil{return err
        }if!fi.Mode().IsRegular(){returnnil}

        targets = append(targets,fpath)returnnil})for _,target := range targets {
        f, err := os.Open(target)if err !=nil{
            fmt.Println("bad target:",target,"error:",err)//prints error: too many open filesbreak}
        defer f.Close()//will not be closed at the end of this code block//do something with the file...}}

解決這個問題的一個方法是把代碼塊寫成一個函數。

package main

import("fmt""os""path/filepath")

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

    start, err := os.Stat(os.Args[1])if err !=nil||!start.IsDir(){
        os.Exit(-1)}var targets []string
    filepath.Walk(os.Args[1], func(fpath string,fi os.FileInfo, err error) error {if err !=nil{return err
        }if!fi.Mode().IsRegular(){returnnil}

        targets = append(targets,fpath)returnnil})for _,target := range targets {
        func(){
            f, err := os.Open(target)if err !=nil{
                fmt.Println("bad target:",target,"error:",err)return}
            defer f.Close()//ok//do something with the file...}()}}

另外一個方法是去掉 defer語句 :-)

失敗的類型斷言

level: intermediate

失敗的類型斷言返回斷言聲明中使用的目標類型的「零值」。這在與隱藏變量混合時，會發生未知狀況。

Incorrect:

package main

import"fmt"

func main(){var data interface{}="great"if data, ok := data.(int); ok {
        fmt.Println("[is an int] value =>",data)}else{
        fmt.Println("[not an int] value =>",data)//prints: [not an int] value => 0 (not "great")}}

Works:

package main

import"fmt"

func main(){var data interface{}="great"if res, ok := data.(int); ok {
        fmt.Println("[is an int] value =>",res)}else{
        fmt.Println("[not an int] value =>",data)//prints: [not an int] value => great (as expected)}}

阻塞的Goroutine和資源泄露

level: intermediate

Rob Pike在2012年的Google I/O大會上所作的「Go Concurrency Patterns」的演講上，說道過幾種基礎的併發模式。從一組目標中獲取第一個結果就是其中之一。

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

這個函數在每次搜索重複時都會起一個goroutine。每一個goroutine把它的搜索結果發送到結果的channel中。結果channel的第一個值被返回。

那其餘goroutine的結果會怎樣呢？還有那些goroutine自身呢？

在 First()函數中的結果channel是沒緩存的。這意味着只有第一個goroutine返回。其餘的goroutine會困在嘗試發送結果的過程當中。這意味着，若是你有不止一個的重複時，每一個調用將會泄露資源。

爲了不泄露，你須要確保全部的goroutine退出。一個不錯的方法是使用一個有足夠保存全部緩存結果的channel。

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
}

另外一個不錯的解決方法是使用一個有 default狀況的 select語句和一個保存一個緩存結果的channel。 default狀況保證了即便當結果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
}

你也可使用特殊的取消channel來終止workers。

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
}

爲什麼在演講中會包含這些bug？Rob Pike僅僅是不想把演示覆雜化。這麼做是合理的，但對於Go新手而言，可能會直接使用代碼，而不去思考它可能有問題。

高級篇

使用指針接收方法的值的實例

level: advanced

只要值是可取址的，那在這個值上調用指針接收方法是沒問題的。換句話說，在某些狀況下，你不須要在有一個接收值的方法版本。

然而並非全部的變量是可取址的。Map的元素就不是。經過interface引用的變量也不是。

package main

import"fmt"

type data struct{  
    name string}

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

type printer interface{print()}

func main(){  
    d1 := data{"one"}
    d1.print()//okvarin printer = data{"two"}//errorin.print()

    m := map[string]data {"x":data{"three"}}
    m["x"].print()//error}

Compile Errors:

/tmp/sandbox017696142/main.go:21: cannot use data literal (type data)as type printer in assignment: data does not implement printer (print method has pointer receiver)/tmp/sandbox017696142/main.go:25: cannot call pointer method on m["x"]/tmp/sandbox017696142/main.go:25: cannot take the address of m["x"]

更新Map的值

level: advanced

若是你有一個struct值的map，你沒法更新單個的struct值。

Fails:

package main

type data struct{  
    name string}

func main(){  
    m := map[string]data {"x":{"one"}}
    m["x"].name ="two"//error}

Compile Error:

/tmp/sandbox380452744/main.go:9: cannot assign to m["x"].name

這個操做無效是由於map元素是沒法取址的。

而讓Go新手更加困惑的是slice元素是能夠取址的。

package main

import"fmt"

type data struct{  
    name string}

func main(){  
    s :=[]data {{"one"}}
    s[0].name ="two"//ok
    fmt.Println(s)//prints: [{two}]}

注意在不久以前，使用編譯器之一（gccgo）是能夠更新map的元素值的，但這一行爲很快就被修復了 :-)它也被認爲是Go 1.3的潛在特性。在那時還不是要急需支持的，但依舊在todo list中。

第一個有效的方法是使用一個臨時變量。

package main

import"fmt"

type data struct{  
    name string}

func main(){  
    m := map[string]data {"x":{"one"}}
    r := m["x"]
    r.name ="two"
    m["x"]= r
    fmt.Printf("%v",m)//prints: map[x:{two}]}

另外一個有效的方法是使用指針的map。

package main

import"fmt"

type data struct{  
    name string}

func main(){  
    m := map[string]*data {"x":{"one"}}
    m["x"].name ="two"//ok
    fmt.Println(m["x"])//prints: &{two}}

順便說下，當你運行下面的代碼時會發生什麼？

package main

type data struct{  
    name string}

func main(){  
    m := map[string]*data {"x":{"one"}}
    m["z"].name ="what?"//???}

"nil" Interfaces和"nil" Interfaces的值

level: advanced

這在Go中是第二最多見的技巧，由於interface雖然看起來像指針，但並非指針。interface變量僅在類型和值爲「nil」時才爲「nil」。

interface的類型和值會根據用於建立對應interface變量的類型和值的變化而變化。當你檢查一個interface變量是否等於「nil」時，這就會致使未預期的行爲。

package main

import"fmt"

func main(){var data *bytevarininterface{}

    fmt.Println(data,data ==nil)//prints: <nil> true
    fmt.Println(in,in==nil)//prints: <nil> truein= data
    fmt.Println(in,in==nil)//prints: <nil> false//'data' is 'nil', but 'in' is not 'nil'}

當你的函數返回interface時，當心這個陷阱。

Incorrect:

package main

import"fmt"

func main(){  
    doit := func(arg int)interface{}{var result *struct{}=nilif(arg >0){
            result =&struct{}{}}return result
    }if res := doit(-1); res !=nil{
        fmt.Println("good result:",res)//prints: good result: <nil>//'res' is not 'nil', but its value is 'nil'}}

Works:

package main

import"fmt"

func main(){  
    doit := func(arg int)interface{}{var result *struct{}=nilif(arg >0){
            result =&struct{}{}}else{returnnil//return an explicit 'nil'}return result
    }if res := doit(-1); res !=nil{
        fmt.Println("good result:",res)}else{
        fmt.Println("bad result (res is nil)")//here as expected}}

棧和堆變量

level: advanced

你並不老是知道變量是分配到棧仍是堆上。在C++中，使用 new建立的變量老是在堆上。在Go中，即便是使用 new()或者 make()函數來分配，變量的位置仍是由編譯器決定。編譯器根據變量的大小和「泄露分析」的結果來決定其位置。這也意味着在局部變量上返回引用是沒問題的，而這在C或者C++這樣的語言中是不行的。

若是你想知道變量分配的位置，在「go build」或「go run」上傳入「-m「 gc標誌（即， go run -gcflags -m app.go）。

GOMAXPROCS, 併發, 和並行

level: advanced

默認狀況下，Go僅使用一個執行上下文/OS線程（在當前的版本）。這個數量能夠經過設置 GOMAXPROCS來提升。

一個常見的誤解是， GOMAXPROCS表示了CPU的數量，Go將使用這個數量來運行goroutine。而 runtime.GOMAXPROCS()函數的文檔讓人更加的迷茫。 GOMAXPROCS變量描述（https://golang.org/pkg/runtime/）所討論OS線程的內容比較好。

你能夠設置 GOMAXPROCS的數量大於CPU的數量。 GOMAXPROCS的最大值是256。

package main

import("fmt""runtime")

func main(){  
    fmt.Println(runtime.GOMAXPROCS(-1))//prints: 1
    fmt.Println(runtime.NumCPU())//prints: 1 (on play.golang.org)
    runtime.GOMAXPROCS(20)
    fmt.Println(runtime.GOMAXPROCS(-1))//prints: 20
    runtime.GOMAXPROCS(300)
    fmt.Println(runtime.GOMAXPROCS(-1))//prints: 256}

讀寫操做的重排順序

level: advanced

Go可能會對某些操做進行從新排序，但它能保證在一個goroutine內的全部行爲順序是不變的。然而，它並不保證多goroutine的執行順序。

package main

import("runtime""time")var _ = runtime.GOMAXPROCS(3)var a, b int

func u1(){  
    a =1
    b =2}

func u2(){  
    a =3
    b =4}

func p(){  
    println(a)
    println(b)}

func main(){  
    go u1()
    go u2()
    go p()
    time.Sleep(1* time.Second)}

若是你多運行幾回上面的代碼，你可能會發現 a和 b變量有多個不一樣的組合：

1234020014

a和 b最有趣的組合式是 "02"。這代表 b在 a以前更新了。

若是你須要在多goroutine內放置讀寫順序的變化，你將須要使用channel，或者使用"sync"包構建合適的結構體。

優先調度

level: advanced

有可能會出現這種狀況，一個無恥的goroutine阻止其餘goroutine運行。當你有一個不讓調度器運行的 for循環時，這就會發生。

package main

import"fmt"

func main(){done:=false

    go func(){done=true}()for!done{}
    fmt.Println("done!")}

for循環並不須要是空的。只要它包含了不會觸發調度執行的代碼，就會發生這種問題。

調度器會在GC、「go」聲明、阻塞channel操做、阻塞系統調用和lock操做後運行。它也會在非內聯函數調用後執行。

package main

import"fmt"

func main(){done:=false

    go func(){done=true}()for!done{
        fmt.Println("not done!")//not inlined}
    fmt.Println("done!")}

要想知道你在 for循環中調用的函數是不是內聯的，你能夠在「go build」或「go run」時傳入「-m」 gc標誌（如， go build -gcflags -m）。

另外一個選擇是顯式的喚起調度器。你可使用「runtime」包中的 Goshed()函數。

package main

import("fmt""runtime")

func main(){done:=false

    go func(){done=true}()for!done{
        runtime.Gosched()}
    fmt.Println("done!")}

Tags: golang, 翻譯, 常見錯誤

/* * * CONFIGURATION VARIABLES * * */
				var disqus_shortname = 'levysink';
                var disqus_config = function () {
                    this.page.url = [location.protocol, '//', location.host, location.pathname].join('');
                    this.page.identifier = [location.protocol, '//', location.host, location.pathname].join('');
                };

				/* * * DON'T EDIT BELOW THIS LINE * * */
				(function() {
					var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
					dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
					(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
				})();
			Please enable JavaScript to view the [comments powered by Disqus.](https://disqus.com/?ref_noscript)

原文地址: levy.at/blog/11

Go的50坑：新Golang開發者要注意的陷阱、技巧和常見錯誤[2]

目錄

進階篇

關閉HTTP的響應

關閉HTTP的鏈接

比較Structs, Arrays, Slices, and Maps

從Panic中恢復

在Slice, Array, and Map "range"語句中更新引用元素的值

在Slice中"隱藏"數據

Slice的數據「毀壞」

"走味的"Slices

類型聲明和方法

從"for switch"和"for select"代碼塊中跳出

"for"聲明中的迭代變量和閉包

Defer函數調用參數的求值

被Defer的函數調用執行

失敗的類型斷言

阻塞的Goroutine和資源泄露

高級篇

使用指針接收方法的值的實例

更新Map的值

"nil" Interfaces和"nil" Interfaces的值

棧和堆變量

GOMAXPROCS, 併發, 和並行

讀寫操做的重排順序

優先調度