本人最近因為專案需要，故開始學習golang(簡稱go)，下面是我最近學習中查閱相關資料整理出來的，對於像我一樣剛入門的初學者很有幫助！希望對你也有幫助！

1.開大括號不能放在單獨的一行

在大多數其他使用大括號的語言中，你需要選擇放置它們的位置。Go的方式不同。你可以為此感謝下自動分號的注入（沒有預讀）。是的，Go中也是有分號的：-）失敗的例子：

package main

import "fmt"

func main()

{ //error, can't have the opening brace on a separate line

fmt.Println( "hello there!"

)

}

編譯錯誤：

/tmp/sandbox826898458/main.go:6: syntax error: unexpected semicolon or newline before {

有效的例子：

package main

import "fmt"

func main() {

fmt.Println( "works!" )

}

2.變數

未使用的變數

如果你有未使用的變數，程式碼將編譯失敗。當然也有例外。在函式內一定要使用宣告的變數，但未使用的全域性變數是沒問題的。

如果你給未使用的變數分配了一個新的值，程式碼還是會編譯失敗。你需要在某個地方使用這個變數，才能讓編譯器愉快的編譯。

Fails:

package main

var gvar int //not an error

func main() {

var one int //error, unused variable

two := 2 //error, unused variable

var three int //error, even though it's assigned 3 on the next line

three = 3

}

Compile Errors:

/tmp/sandbox473116179/main.go:6: one declared and not used

/tmp/sandbox473116179/main.go:7: two declared and not used

/tmp/sandbox473116179/main.go:8: three declared and not used

Works:

package main

import "fmt"

func main() {

var one int

_ = one

two := 2

fmt.Println(two)

var three int

three = 3

one = three

var four int

four = four

}

另一個選擇是註釋掉或者移除未使用的變數 ：-）

未使用的Imports

如果你引入一個包，而沒有使用其中的任何函式、介面、結構體或者變數的話，程式碼將會編譯失敗。如果你真的需要引入的包，你可以新增一個下劃線標記符，_，來作為這個包的名字，從而避免編譯失敗。下滑線標記符用於引入，但不使用。

Fails:

package main

import (

"fmt"

"log"

"time"

)

func main() {

}

Compile Errors:

/tmp/sandbox627475386/main.go:4: imported and not used: "fmt"

/tmp/sandbox627475386/main.go:5: imported and not used: "log"

/tmp/sandbox627475386/main.go:6: imported and not used: "time"

Works:

package main

import (

_ "fmt"

"log"

"time"

)

var _ = log.Println

func main() {

_ = time.Now

}

另一個選擇是移除或者註釋掉未使用的imports ：-）

簡式的變數宣告僅可以在函式內部使用

Fails:

package main

myvar := 1 //error

func main() {

}

Compile Error:

/tmp/sandbox265716165/main.go:3: non-declaration statement outside function body

Works:

package main

var myvar = 1

func main() {}

}

使用簡式宣告重複宣告變數

你不能在一個單獨的宣告中重複宣告一個變數，但在多變數宣告中這是允許的，其中至少要有一個新的宣告變數。

重複變數需要在相同的程式碼塊內，否則你將得到一個隱藏變數。

Fails:

package main

func main() {

one := 0

one := 1 //error

}

Compile Error:

/tmp/sandbox706333626/main.go:5: no new variables on left side of :=

Works:

package main

func main() {

one := 0

one, two := 1 ,2

one,two = two,one

}

偶然的變數隱藏Accidental Variable Shadowing

短式變數宣告的語法如此的方便（尤其對於那些使用過動態語言的開發者而言），很容易讓人把它當成一個正常的分配操作。如果你在一個新的程式碼塊中犯了這個錯誤，將不會出現編譯錯誤，但你的應用將不會做你所期望的事情。

package main

import "fmt"

func main() {

x := 1

fmt.Println(x) //prints 1

{

fmt.Println(x) //prints 1

x := 2

fmt.Println(x) //prints 2

}

fmt.Println(x) //prints 1 (bad if you need 2)

}

即使對於經驗豐富的Go開發者而言，這也是一個非常常見的陷阱。這個坑很容易挖，但又很難發現。

你可以使用 vet 命令來發現一些這樣的問題。 預設情況下，vet不會執行這樣的檢查，你需要設定-shadow引數：

go tool vet -shadow your_file.go。

不使用顯式型別，無法使用“nil”來初始化變數

nil標誌符用於表示interface、函式、maps、slices和channels的“零值”。如果你不指定變數的型別，編譯器將無法編譯你的程式碼，因為它猜不出具體的型別。

Fails:

package main

func main() {

var x = nil //error

_ = x

}

Compile Error:

/tmp/sandbox188239583/main.go:4: use of untyped nil

Works:

package main

func main() {

var x interface {} = nil

_ = x

}

使用“nil” Slices and Maps

在一個nil的slice中新增元素是沒問題的，但對一個map做同樣的事將會生成一個執行時的panic。

Works:

package main

func main() {

var s [] int

s = append (s ,1 )

}

Fails:

package main

func main() {

var m map [ string ] int

m[ "one" ] = 1 //error

}

3.Map的容量

你可以在map建立時指定它的容量，但你無法在map上使用cap()函式。

Fails:

package main

func main() {

m := make ( map [ string ] int,99 )

cap (m) //error

}

Compile Error:

/tmp/sandbox326543983/main.go:5: invalid argument m (type map[string]int) for cap

4.字串不會為nil

這對於經常使用nil分配字串變數的開發者而言是個需要注意的地方。

Fails:

package main

func main() {

var x string = nil //error

if x == nil { //error

x = "default"

}

}

Compile Errors:

/tmp/sandbox630560459/main.go:4: cannot use nil as type string in assignment /tmp/sandbox630560459/main.go:6: invalid operation: x == nil (mismatched types string and nil)

Works:

package main

func main() {

var x string //defaults to "" (zero value)

if x == "" {

x = "default"

}

}

5.Array函式的引數

如果你是一個C或則C++開發者，那麼陣列對你而言就是指標。當你向函式中傳遞陣列時，函式會參照相同的記憶體區域，這樣它們就可以修改原始的資料。Go中的陣列是數值，因此當你向函式中傳遞陣列時，函式會得到原始陣列資料的一份複製。如果你打算更新陣列的資料，這將會是個問題。

package main

import "fmt"

func main() {

x := [3 ] int {1 ,2 ,3 }

func (arr [3 ] int ) {

arr [0 ] = 7

fmt.Println(arr) //prints [7 2 3]

}(x)

fmt.Println(x) //prints [1 2 3] (not ok if you need [7 2 3])

}

如果你需要更新原始陣列的資料，你可以使用陣列指標型別。

package main

import "fmt"

func main() {

x := [3 ] int {1 ,2 ,3 }

func (arr * [3 ] int ) {

(*arr) [0 ] = 7

fmt.Println(arr) //prints &[7 2 3]

}(&x)

fmt.Println(x) //prints [7 2 3]

}

另一個選擇是使用slice。即使你的函式得到了slice變數的一份拷貝，它依舊會參照原始的資料。

package main

import "fmt"

func main() {

x := [] int {1 ,2 ,3 }

func (arr [] int ) {

arr [0 ] = 7

fmt.Println(arr) //prints [7 2 3]

}(x)

fmt.Println(x) //prints [7 2 3]

}

6.在Slice和Array使用“range”語句時的出現的不希望得到的值

如果你在其他的語言中使用“for-in”或者“foreach”語句時會發生這種情況。Go中的“range”語法不太一樣。它會得到兩個值：第一個值是元素的索引，而另一個值是元素的資料。Bad:

package main

import "fmt"

func main() {

x := [] string { "a" , "b" , "c" }

for v := range x {

fmt.Println(v) //prints 0, 1, 2

}

}

Good:

package main

import "fmt"

func main() {

x := [] string { "a" , "b" , "c" }

for _, v := range x {

fmt.Println(v) //prints a, b, c

}

}

7.Slices和Arrays是一維的

看起來Go好像支援多維的Array和Slice，但不是這樣的。儘管可以建立陣列的陣列或者切片的切片。對於依賴於動態多維陣列的數值計算應用而言，Go在效能和複雜度上還相距甚遠。

你可以使用純一維陣列、“獨立”切片的切片，“共享資料”切片的切片來構建動態的多維陣列。

如果你使用純一維的陣列，你需要處理索引、邊界檢查、當陣列需要變大時的記憶體重新分配。

使用“獨立”slice來建立一個動態的多維陣列需要兩步。首先，你需要建立一個外部的slice。然後，你需要分配每個內部的slice。內部的slice相互之間獨立。你可以增加減少它們，而不會影響其他內部的slice。

package main

func main() {

x := 2

y := 4

table := make ([][] int ,x)

for i:= range table {

table[i] = make ([] int ,y)

}

}

使用“共享資料”slice的slice來建立一個動態的多維陣列需要三步。首先，你需要建立一個用於存放原始資料的資料“容器”。然後，你再建立外部的slice。最後，通過重新切片原始資料slice來初始化各個內部的slice。

package main

import "fmt"

func main() {

h, w := 2 , 4

raw := make ([] int ,h*w)

for i := range raw {

raw[i] = i

}

fmt.Println(raw,&raw [4 ])

//prints: [0 1 2 3 4 5 6 7] <ptr_addr_x>

table := make ([][] int ,h)

for i:= range table {

table[i] = raw[i*w:i*w + w]

}

fmt.Println(table,&table [1 ] [0 ])

//prints: [[0 1 2 3] [4 5 6 7]] <ptr_addr_x>

}

關於多維array和slice已經有了專門申請，但現在看起來這是個低優先順序的特性。

8.訪問不存在的Map Keys

這對於那些希望得到“nil”標示符的開發者而言是個技巧（和其他語言中做的一樣）。如果對應的資料型別的“零值”是“nil”，那返回的值將會是“nil”，但對於其他的資料型別是不一樣的。檢測對應的“零值”可以用於確定map中的記錄是否存在，但這並不總是可信（比如，如果在二值的map 中“零值”是false，這時你要怎麼做）。檢測給定map中的記錄是否存在的最可信的方法是，通過map的訪問操作，檢查第二個返回的值。

Bad:

package main

import "fmt"

func main() {

x := map [ string ] string { "one" :"a" , "two" : "" , "three" : "c" }

if v := x[ "two" ]; v == "" { //incorrect

fmt.Println( "no entry" )

}

}

Good:

package main

import "fmt"

func main() {

x := map [ string ] string { "one" :"a" , "two" : "" , "three" : "c" }

if _,ok := x[ "two" ]; !ok {

fmt.Println( "no entry" )

}

}

9.Strings無法修改

嘗試使用索引操作來更新字串變數中的單個字元將會失敗。string是隻讀的byte slice（和一些額外的屬性）。如果你確實需要更新一個字串，那麼使用byte slice，並在需要時把它轉換為string型別。

Fails:

package main

import "fmt"

func main() {

x := "text"

x [0 ] = 'T'

fmt.Println(x)

}

Compile Error:

/tmp/sandbox305565531/main.go:7: cannot assign to x[0]

Works:

package main

import "fmt"

func main() {

x := "text"

xbytes := [] byte (x)

xbytes [0 ] = 'T'

fmt.Println( string (xbytes)) //prints Text

}

需要注意的是：這並不是在文字string中更新字元的正確方式，因為給定的字元可能會儲存在多個byte中。如果你確實需要更新一個文字 string，先把它轉換為一個rune slice。即使使用rune slice，單個字元也可能會佔據多個rune，比如當你的字元有特定的重音符號時就是這種情況。這種複雜又模糊的“字元”本質是Go字串使用byte 序列表示的原因。

10.String和Byte Slice之間的轉換

當你把一個字串轉換為一個byte slice（或者反之）時，你就得到了一個原始資料的完整拷貝。這和其他語言中cast操作不同，也和新的slice變數指向原始byteslice使用的相同陣列時的重新slice操作不同。

Go在[]byte到string和string到[]byte的轉換中確實使用了一些優化來避免額外的分配（在todo列表中有更多的優化）。

第一個優化避免了當[]bytekeys用於在map[string]集合中查詢時的額外分配:m[string(key)]。

第二個優化避免了字串轉換為[]byte後在for range語句中的額外分配：for i,v := range []byte(str) {...}。

11.String和索引操作

字串上的索引操作返回一個byte值，而不是一個字元（和其他語言中的做法一樣）。

package main

import "fmt"

func main() {

x := "text"

fmt.Println(x [0 ]) //print 116

fmt.Printf( "%T" ,x [0 ]) //prints uint8

}

如果你需要訪問特定的字串“字元”（unicode編碼的points/runes），使用for range。官方的“unicode/utf8”包和實驗中的utf8string包（golang.org/x/exp/utf8string）也可以用。utf8string包中包含了一個很方便的At()方法。把字串轉換為rune的切片也是一個選項。

12.字串不總是UTF8文字

字串的值不需要是UTF8的文字。它們可以包含任意的位元組。只有在string literal使用時，字串才會是UTF8。即使之後它們可以使用轉義序列來包含其他的資料。

為了知道字串是否是UTF8，你可以使用“unicode/utf8”包中的ValidString()函式。

package main

import (

"fmt"

"unicode/utf8"

)

func main() {

data1 := "ABC"

fmt.Println(utf8.ValidString(data1)) //prints: true

data2 := "A\xfeC"

fmt.Println(utf8.ValidString(data2)) //prints: false

}

13.字串的長度

讓我們假設你是Python開發者，你有下面這段程式碼：

data = u'♥'

print(len(data)) #prints: 1

當把它轉換為Go程式碼時，你可能會大吃一驚。

package main

import "fmt"

func main() {

data := "♥"

fmt.Println( len (data)) //prints: 3

}

內建的len()函式返回byte的數量，而不是像Python中計算好的unicode字串中字元的數量。

要在Go中得到相同的結果，可以使用“unicode/utf8”包中的RuneCountInString()函式。

package main

import (

"fmt"

"unicode/utf8"

)

func main() {

data := "♥"

fmt.Println(utf8.RuneCountInString(data)) //prints: 1

}

理論上說RuneCountInString()函式並不返回字元的數量，因為單個字元可能佔用多個rune。

package main

import (

"fmt"

"unicode/utf8"

)

func main() {

data := "é"

fmt.Println( len (data)) //prints: 3

fmt.Println(utf8.RuneCountInString(data)) //prints: 2

}

14.在多行的Slice、Array和Map語句中遺漏逗號

Fails:

package main

func main() {

x := [] int {

1 ,

2 //error

}

_ = x

}

Compile Errors:

/tmp/sandbox367520156/main.go:6: syntax error: need trailing comma before newline in composite literal /tmp/sandbox367520156/main.go:8: non-declaration statement outside function body /tmp/sandbox367520156/main.go:9: syntax error: unexpected }

Works:

package main

func main() {

x := [] int {

1 ,

2 ,

}

x = x

y := [] int {3 ,4 ,} //no error

y = y

}

當你把宣告摺疊到單行時，如果你沒加末尾的逗號，你將不會得到編譯錯誤。

15.log.Fatal和log.Panic不僅僅是Log

Logging庫一般提供不同的log等級。與這些logging庫不同，Go中log包在你呼叫它的Fatal*()和Panic*()函式時，可以做的不僅僅是log。當你的應用呼叫這些函式時，Go也將會終止應用 :-)

package main

import "log"

func main() {

log.Fatalln( "Fatal Level: log entry" ) //app exits here

log.Println( "Normal Level: log entry" )

}

16.內建的資料結構操作不是同步的

即使Go本身有很多特性來支援併發，併發安全的資料集合並不是其中之一 :-)確保資料集合以原子的方式更新是你的職責。Goroutines和channels是實現這些原子操作的推薦方式，但你也可以使用“sync”包，如果它對你的應用有意義的話。

17.String在“range”語句中的迭代值

索引值（“range”操作返回的第一個值）是返回的第二個值的當前“字元”（unicode編碼的point/rune）的第一個byte的索引。它不是當前“字元”的索引，這與其他語言不同。注意真實的字元可能會由多個rune表示。如果你需要處理字元，確保你使用了“norm”包（golang.org/x/text/unicode/norm）。

string變數的for range語句將會嘗試把資料翻譯為UTF8文字。對於它無法理解的任何byte序列，它將返回0xfffd runes（即unicode替換字元），而不是真實的資料。如果你任意（非UTF8文字）的資料儲存在string變數中，確保把它們轉換為byte slice，以得到所有儲存的資料。

package main

import "fmt"

func main() {

data := "A\xfe\x02\xff\x04"

for _,v := range data {

fmt.Printf( "%#x " ,v)

}

//prints: 0x41 0xfffd 0x2 0xfffd 0x4 (not ok)

fmt.Println()

for _,v := range [] byte (data) {

fmt.Printf( "%#x " ,v)

}

//prints: 0x41 0xfe 0x2 0xff 0x4 (good)

}

18.對Map使用“for range”語句迭代

如果你希望以某個順序（比如，按key值排序）的方式得到元素，就需要這個技巧。每次的map迭代將會生成不同的結果。Go的runtime有心嘗試隨機化迭代順序，但並不總會成功，這樣你可能得到一些相同的map迭代結果。所以如果連續看到5個相同的迭代結果，不要驚訝。

package main

import "fmt"

func main() {

m := map [ string ] int { "one":1 , "two" :2 , "three" :3 , "four" :4 }

for k,v := range m {

fmt.Println(k,v)

}

}

19."switch"宣告中的失效行為

在“switch”宣告語句中的“case”語句塊在預設情況下會break。這和其他語言中的進入下一個“next”程式碼塊的預設行為不同。

package main

import "fmt"

func main() {

isSpace := func (ch byte ) bool {

switch (ch) {

case ' ' : //error

case '\t' :

return true

}

return false

}

fmt.Println(isSpace( '\t' )) //prints true (ok)

fmt.Println(isSpace( ' ' )) //prints false (not ok)

}

你可以通過在每個“case”塊的結尾使用“fallthrough”，來強制“case”程式碼塊進入。你也可以重寫switch語句，來使用“case”塊中的表示式列表。

package main

import "fmt"

func main() {

isSpace := func (ch byte ) bool {

switch (ch) {

case ' ' , '\t' :

return true

}

return false

}

fmt.Println(isSpace( '\t' )) //prints true (ok)

fmt.Println(isSpace( ' ' )) //prints true (ok)

}

20.自增和自減

許多語言都有自增和自減操作。不像其他語言，Go不支援前置版本的操作。你也無法在表示式中使用這兩個操作符。Fails:

package main

import "fmt"

func main() {

data := [] int {1 ,2 ,3 }

i := 0

++i //error

fmt.Println(data[i++]) //error

}

Compile Errors:

/tmp/sandbox101231828/main.go:8: syntax error: unexpected ++ /tmp/sandbox101231828/main.go:9: syntax error: unexpected ++, expecting :

Works:

package main

import "fmt"

func main() {

data := [] int {1 ,2 ,3 }

i := 0

i++

fmt.Println(data[i])

}

21.按位NOT操作

許多語言使用~作為一元的NOT操作符（即按位補足），但Go為了這個重用了XOR操作符（^）。

Fails:

package main

import "fmt"

func main() {

fmt.Println( ~2 ) //error

}

Compile Error:

/tmp/sandbox965529189/main.go:6: the bitwise complement operator is ^

Works:

package main

import "fmt"

func main() {

var d uint8 = 2

fmt.Printf( "%08b\n" ,^d)

}

Go依舊使用^作為XOR的操作符，這可能會讓一些人迷惑。

如果你願意，你可以使用一個二元的XOR操作（如， 0x02 XOR 0xff）來表示一個一元的NOT操作（如，NOT 0x02）。這可以解釋為什麼^被重用來表示一元的NOT操作。

Go也有特殊的‘AND NOT’按位操作（&^），這也讓NOT操作更加的讓人迷惑。這看起來需要特殊的特性/hack來支援A AND (NOT B)，而無需括號。

package main

import "fmt"

func main() {

var a uint8 = 0 x82

var b uint8 = 0 x02

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 ,0 xff,b ^0 xff)

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

}

22.操作優先順序的差異

除了”bit clear“操作（&^），Go也一個與許多其他語言共享的標準操作符的集合。儘管操作優先順序並不總是一樣。

package main

import "fmt"

func main() {

fmt.Printf( "0x2 & 0x2 + 0x4 -> %#x\n" ,0 x2 & 0 x2 + 0 x4)

//prints: 0x2 & 0x2 + 0x4 -> 0x6

//Go: (0x2 & 0x2) + 0x4

//C++: 0x2 & (0x2 + 0x4) -> 0x2

fmt.Printf( "0x2 + 0x2 << 0x1 -> %#x\n" ,0 x2 + 0 x2 << 0 x1)

//prints: 0x2 + 0x2 << 0x1 -> 0x6

//Go: 0x2 + (0x2 << 0x1)

//C++: (0x2 + 0x2) << 0x1 -> 0x8

fmt.Printf( "0xf | 0x2 ^ 0x2 -> %#x\n" ,0 xf | 0 x2 ^ 0 x2)

//prints: 0xf | 0x2 ^ 0x2 -> 0xd

//Go: (0xf | 0x2) ^ 0x2

//C++: 0xf | (0x2 ^ 0x2) -> 0xf

}

23.未匯出的結構體不會被編碼

以小寫字母開頭的結構體將不會被（json、xml、gob等）編碼，因此當你編碼這些未匯出的結構體時，你將會得到零值。

Fails:

package main

import (

"fmt"

"encoding/json"

)

type MyData struct {

One int

two string

}

func main() {

in := MyData {1 , "two" }

fmt.Printf( "%#v\n" ,in) //prints main.MyData{One:1, two:"two"}

encoded,_ := json.Marshal(in)

fmt.Println( string (encoded)) //prints {"One":1}

var out MyData

json.Unmarshal(encoded,&out)

fmt.Printf( "%#v\n" ,out) //prints main.MyData{One:1, two:""}

}

24.有活動的Goroutines下的應用退出

應用將不會等待所有的goroutines完成。這對於初學者而言是個很常見的錯誤。每個人都是以某個程度開始，因此如果犯了初學者的錯誤也沒神馬好丟臉的 :-)

package main

import (

"fmt"

"time"

)

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)

fmt.Printf( "[%v] is done\n" ,workerId)

}

你將會看到：

[ 0 ] is running

[ 1 ] is running

all done!

一個最常見的解決方法是使用“WaitGroup”變數。它將會讓主goroutine等待所有的worker goroutine完成。如果你的應用有長時執行的訊息處理迴圈的worker，你也將需要一個方法向這些goroutine傳送訊號，讓它們退出。你可以給各個worker傳送一個“kill”訊息。另一個選項是關閉一個所有worker都接收的channel。這是一次向所有goroutine傳送訊號的簡單方式。

package main

import (

"fmt"

"sync"

)

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)

}

如果你執行這個應用，你將會看到：

[ 0 ] is running

[ 0 ] is done

[ 1 ] is running

[ 1 ] is done

看起來所有的worker在主goroutine退出前都完成了。棒！然而，你也將會看到這個：

fatal error : all goroutines are asleep - deadlock!

這可不太好 :-) 傳送了神馬？為什麼會出現死鎖？worker退出了，它們也執行了wg.Done()。應用應該沒問題啊。

死鎖發生是因為各個worker都得到了原始的“WaitGroup”變數的一個拷貝。當worker執行wg.Done()時，並沒有在主goroutine上的“WaitGroup”變數上生效。

package main

import (

"fmt"

"sync"

)

func main() {

var wg sync.WaitGroup

done := make ( chan struct {})

wq := make ( chan interface {})

workerCount := 2

for i := 0 ; i < workerCount; i++ {

wg.Add (1 )

go doit(i,wq,done,&wg)

}

for i := 0 ; i < workerCount; i++ {

wq <- i

}

close (done)

wg.Wait()

fmt.Println( "all done!" )

}

func doit(workerId int , wq <- chan interface {},done <- chan struct {},wg *sync.WaitGroup) {

fmt.Printf( "[%v] is running\n" ,workerId)

defer wg.Done()

for {

select {

case m := <- wq:

fmt.Printf( "[%v] m => %v\n" ,workerId,m)

case <- done:

fmt.Printf( "[%v] is done\n" ,workerId)

return

}

}

}

現在它會如預期般工作 :-)

25.向無快取的Channel傳送訊息，只要目標接收者準備好就會立即返回

傳送者將不會被阻塞，除非訊息正在被接收者處理。根據你執行程式碼的機器的不同，接收者的goroutine可能會或者不會有足夠的時間，在傳送者繼續執行前處理訊息。

package main

import "fmt"

func main() {

ch := make ( chan string )

go func () {

for m := range ch {

fmt.Println( "processed:" ,m)

}

}()

ch <- "cmd.1"

ch <- "cmd.2" //won't be processed

}

26.向已關閉的Channel傳送會引起Panic

從一個關閉的channel接收是安全的。在接收狀態下的ok的返回值將被設定為false，這意味著沒有資料被接收。如果你從一個有快取的channel接收，你將會首先得到快取的資料，一旦它為空，返回的ok值將變為false。

向關閉的channel中傳送資料會引起panic。這個行為有文件說明，但對於新的Go開發者的直覺不同，他們可能希望傳送行為與接收行為很像。

package main

import (

"fmt"

"time"

)

func main() {

ch := make ( chan int )

for i := 0 ; i < 3 ; i++ {

go func (idx int ) {

ch <- (idx + 1 ) * 2

}(i)

}

//get the first result

fmt.Println(<-ch)

close (ch) //not ok (you still have other senders)

//do other work

time.Sleep (2 * time.Second)

}

根據不同的應用，修復方法也將不同。可能是很小的程式碼修改，也可能需要修改應用的設計。無論是哪種方法，你都需要確保你的應用不會向關閉的channel中傳送資料。

上面那個有bug的例子可以通過使用一個特殊的廢棄的channel來向剩餘的worker傳送不再需要它們的結果的訊號來修復。

package main

import (

"fmt"

"time"

)

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,"sent result" )

case <- done: fmt.Println(idx, "exiting" )

}

}(i)

}

//get first result

fmt.Println( "result:" ,<-ch)

close (done)

//do other work

time.Sleep (3 * time.Second)

}

27.使用"nil" Channels

在一個nil的channel上傳送和接收操作會被永久阻塞。這個行為有詳細的文件解釋，但它對於新的Go開發者而言是個驚喜。

package main

import (

"fmt"

"time"

)

func main() {

var ch chan int

for i := 0 ; i < 3 ; i++ {

go func (idx int ) {

ch <- (idx + 1 ) * 2

}(i)

}

//get first result

fmt.Println( "result:" ,<-ch)

//do other work

time.Sleep (2 * time.Second)

}

如果執行程式碼你將會看到一個runtime錯誤：

fatal error : all goroutines are asleep - deadlock!

這個行為可以在select宣告中用於動態開啟和關閉case程式碼塊的方法。

package main

import "fmt"

import "time"

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:

out = nil

in = inch

case val = <- in:

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)

}

28.傳值方法的接收者無法修改原有的值

方法的接收者就像常規的函式引數。如果宣告為值，那麼你的函式/方法得到的是接收者引數的拷貝。這意味著對接收者所做的修改將不會影響原有的值，除非接收者是一個map或者slice變數，而你更新了集合中的元素，或者你更新的域的接收者是指標。

package main

import "fmt"

type data struct {

num int

key * string

items map [ string ] bool

}

func (this *data) pmethod() {

this.num = 7

}

func (this data) vmethod() {

this.num = 8

*this.key = "v.key"

this.items[ "vmethod" ] = true

}

func main() {

key := "key.1"

d := data {1 ,&key, make ( map [ string ] bool )}

fmt.Printf( "num=%v key=%v items=%v\n" ,d.num,*d.key,d.items)

//prints num=1 key=key.1 items=map[]

d.pmethod()

fmt.Printf( "num=%v key=%v items=%v\n" ,d.num,*d.key,d.items)

//prints num=7 key=key.1 items=map[]

d.vmethod()

fmt.Printf( "num=%v key=%v items=%v\n" ,d.num,*d.key,d.items)

//prints num=7 key=v.key items=map[vmethod:true]

}

29.關閉HTTP的響應

當你使用標準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 )

30.關閉HTTP的連線

一些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伺服器傳送一兩個請求，那麼在引用收到響應後立刻關閉網路連線是一個好主意。增加開啟檔案的限制數可能也是個好主意。當然，正確的選擇源自於應用。

31.比較Structs, Arrays, Slices, and Maps

如果結構體中的各個元素都可以用你可以使用等號來比較的話，那就可以使用相號, ==，來比較結構體變數。

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()）。

32.從Panic中恢復

recover()函式可以用於獲取/攔截panic。僅當在一個defer函式中被完成時，呼叫recover()將會完成這個小技巧。

Incorrect:

package 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" )

}

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

在“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]

}

如果你需要更新原有集合中的資料，使用索引操作符來獲得資料。

34.在Slice中"隱藏"資料

當你重新劃分一個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.