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

初級篇
- 開大括號不能放在單獨的一行
- 未使用的變數
- 未使用的Imports
- 簡式的變數宣告僅可以在函式內部使用
- 使用簡式宣告重複宣告變數
- 偶然的變數隱藏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 ok if 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 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) //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" var in interface{} = "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.Lock undefined (type myMutex has no field or method Lock) /tmp/sandbox106401185/main.go:10: mtx.Unlock undefined (type myMutex has no field or method Unlock)

如果你確實需要原有型別的方法，你可以定義一個新的struct型別，用匿名方式把原有型別嵌入其中。

Works:

package main

import "sync"

type myLocker struct {  
    sync.Mutex
}

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

interface型別的宣告也會保留它們的方法集合。

Works:

package main

import "sync"

type myLocker sync.Locker

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

從"for switch"和"for select"程式碼塊中跳出

level: intermediate

沒有標籤的“break”宣告只能從內部的switch/select程式碼塊中跳出來。如果無法使用“return”宣告的話，那就為外部迴圈定義一個標籤是另一個好的選擇。

package main

import "fmt"

func main() { loop: for { switch { case true: 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(in string) { 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() { 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) //prints error: too many open files break } 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() { return nil } targets = append(targets,fpath) return nil }) 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() //ok var in printer = data{"two"} //error in.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 *byte
    var in interface{}

    fmt.Println(data,data == nil) //prints: <nil> true fmt.Println(in,in == nil) //prints: <nil> true in = 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{} { 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    Go的50坑：新Golang開發者要注意的陷阱、技巧和常見錯誤[2]
       
  
  初級篇 
    
    開大括號不能放在單獨的一行 
    未使用的變數 
    未使用的Imports 
    簡式的變數宣告僅可以在函式內部使用 
    使用簡式宣告重複宣告變數 
    偶然的變數隱藏Accidental Variable Shadowing 
    不使用 

  
 

    

    
    Go的50坑：新Golang開發者要注意的陷阱、技巧和常見錯誤[1]
       
  
  初級篇 
    
    開大括號不能放在單獨的一行 
    未使用的變數 
    未使用的Imports 
    簡式的變數宣告僅可以在函式內部使用 
    使用簡式宣告重複宣告變數 
    偶然的變數隱藏Accidental Variable Shadowing 
    不使用 

  
 

    

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


Go是一門簡單有趣的語言，但與其他語言類似，它會有一些技巧。。。這些技巧的絕大部分並不是Go的缺陷造成的。如果你以前使用的是其他語言，那麼這其中的有些錯誤就是很自然的陷阱。其它的是由錯誤的假設和缺少細節造成的。

如果你花時間學習這門語言，閱讀官方說明、wik 

  
 

    

    
    [轉]Go的50坑：新Golang開發者要註意的陷阱、技巧和常見錯誤-高級
      inline   pil   ren   todo   ket   blog   自定義   nec   printf   from : https://levy.at/blog/11
進階篇
關閉HTTP的響應

level: intermediate

當你使用標準http庫發起請求時，你得到 

  
 

    

    
    Go的50度灰：Golang新開發者要注意的陷阱和常見錯誤
       
 
 Go的50度灰：Golang新開發者要注意的陷阱和常見錯誤 
 目錄 [−] 
 
  初級 
   
    開大括號不能放在單獨的一行 
    未使用的變數 
    未使用的Imports 
    簡式的變數宣告僅可以在函式內部使用 
    使用簡式宣告重複宣告變數 
     

  
 

    

    
    Eclipse-ADT版本：用SDKmanager更新時 注意Android SDK Tools和Platforms要匹配，否則開發環境就不正常了
      
								
								            
						
                
EclipseADT外掛開發Android應用程式時，一般使用SDK
 Manager來更新SDK Tools 和Android Platforms 。但是，如果SDK Tools的版本和Androi 

  
 

    

    
    Python千萬要注意的全域性變數和區域性變數問題
       
 
 1、直接在函式中呼叫全域性變數 
 m = 100
def fun():
    print("m1:",m)
fun()
print("m2:", m) 
  輸出： 
  
 2、函式體內呼叫與全域性變數同名的區域性變數 
 m = 100
def fun():
    m = 50
 

  
 

    

    
    JAVA學習（七）：方法重載與方法重寫、thiskeyword和superkeyword
      格式   hello   new   初始   per   而且   方法重寫   學習   方式   

方法重載與方法重寫、thiskeyword和superkeyword


1、方法重載


重載可以使具有同樣名稱但不同數目和類型參數的類傳遞給方法。
註：
一是重載方法的參數列表必須與被重載的方法不同 

  
 

    

    
    github常見操作和常見錯誤！錯誤提示：fatal: remote origin already exists.
      空格   多余   因此   ear   rem   detail   tco   acs   core   如果輸入$ git remote add origin [email protected]:djqiang（github帳號名）/gitdemo（項目名）.git 
    提示出錯信息：fatal: re 

  
 

    

    
    music-api-next：一款支持網易、xiami和QQ音樂的JS爬蟲庫
      dbm   穩定   javascrip   earch   arch   github   服務器   ole   http   音樂，無界

讓音樂無界

如果你苦於挑選一個全方位、多平臺、簡便易用的音樂爬蟲庫，music-api-next是不二選擇。
特性：

支持網易、蝦米和QQ三大主流音樂平臺
支持 

  
 

    

    
    以太坊第2層擴容方案：狀態通道（State Channels）、Plasma 和 Truebit
       
  
  
  
 對於以太坊來說 2018 年是著力基礎建設的一年（https://twitter.com/L4ventures/status/953041925241757697）。今年是初期使用者來測試網路極限的一年，並將重新關注一些擴充套件以太坊的技術。 
 以太坊至今仍處於成長初期。 現今，它還 

  
 

    

    
    golang學習筆記---函數、方法和接口
      動態綁定   多個   依賴   find   輸出   ack   range   支持   不定   函數：對應操作序列，是程序的基本組成元素。
函數有具名和匿名之分：具名函數一般對應於包級的函數，是匿名函數的一種特例，當匿名函數引用了外部作用域中的變量時就成了閉包函數，閉包函數是函數式編程語言的核心。方 

  
 

    

    
    前端每日實戰：136# 視訊演示如何用 CSS、D3 和 GSAP 創作一個橫條 loader
      
                    

效果預覽
按下右側的“點選預覽”按鈕可以在當前頁面預覽，點選連結可以全屏預覽。

可互動視訊
此視訊是可以互動的，你可以隨時暫停視訊，編輯視訊中的程式碼。
請用 chrome, safari, edge 開啟觀看。

原始碼下載
每日前端實戰系列的全部原始碼請從  

  
 

    

    
    理解以太坊的Layer 2擴容解決方案：狀態通道（State Channels）、Plasma 和 Truebit
      
-賓夕法尼亞州的尼科爾森大橋建設照片（圖源）。羅馬人的工程原理擴充套件至新的應用

對於以太坊來說，2018年是專注底層架構之年。今年很多早期參與者會測試網路極限，並且重新關注以太坊的擴容技術。
以太坊仍然處於起步階段。直到現在，它仍然沒有那麼安全或者可擴充套件。對於任何密切關注以太坊技術的人來說，這都是很 

  
 

    

    
    github常見操作和常見錯誤！錯誤提示：fatal: remote origin already exist
      如果輸入$ git remote add origin [email protected]:djqiang（github帳號名）/gitdemo（專案名）.git 
    提示出錯資訊：fatal: remote origin already exists.
    解決辦法如下：
    1、先 

  
 

    

    
    Android Studio專案打包：常見錯誤2：AAPT: libpng error: Not a PNG file
       
 
 
 Generate Signed APK: Errors while building APK. You can find the errors in the 'Messages' view. 
 錯誤資訊： 
 AAPT: libpng error: Not a PNG file 
 FAILU 

  
 

    

    
    大資料：一場改變我們如何生活、工作和思考的革命（讓資料說話）
      
                

讓資料說話
資訊社會的果實很容易被看到，例如每個口袋裡的手機，每個包裡的電腦和在各處辦公室中的大的後臺系統。但不容易看到的是資訊自己。電腦進入主流社會半個世紀以來，資料開始積累到一個點，一些新的特殊的事情即將發生。不僅僅是資訊爆炸，而且資訊增長的速度更快。規模的改變導致狀 

  
 

    

    
    java io系列14：DataInputStream(資料輸入流)的認知、原始碼和示例
       
 
 本章介紹DataInputStream。我們先對DataInputStream有個大致認識，然後再深入學習它的原始碼，最後通過示例加深對它的瞭解。 
 轉載請註明出處：http://www.cnblogs.com/skywang12345/p/io_14.html 
 DataInputStream 

  
 

    

    
    包建強的培訓課程（12）：iOS深入學習（記憶體管理、Block和GCD等）
      





iOS記憶體管理
一簡介
結合講師5年來一線工作經驗，以及對iOS的深刻理解，整理出這個課程，涉及iOS記憶體、Block、GCD和Category的原理和使用。
本課程系列適合於從事iOS開發1-2年的技術人員，幫助他們鞏固基礎，從而在ARC開發環境下高效的使用GCD、Bloc 

  
 

    

    
    shell學習：Linux系統日誌的相關命令、檔案和管理工具
      
                


日誌檔案是Linux系統維必不可少的部分，日誌檔案會隨著時間的推移變的越來越大，需要使用一種被稱為輪替的技術來限制日誌的體積，一旦超過了限制的大小，就對它的內容進行抽取，同時將日誌檔案中的舊條目儲存到歸檔檔案中，以便日後的查閱。
logrotate命令
logrotat