轉載：https://www.luozhiyun.com/archives/206

GOPATH 工作空間

GOPATH簡單理解成Go語言的工作目錄，它的值是一個目錄的路徑，也可以是多個目錄路徑，每個目錄都代表Go語言的一個工作區（workspace）。

在GOPATH放置Go語言的原始碼檔案（source file），以及安裝（install）後的歸檔檔案（archive file，也就是以“.a”為副檔名的檔案）和可執行檔案（executable file）。

原始碼安裝

比如，一個已存在的程式碼包的匯入路徑是

github.com/labstack/echo，

那麼執行命令進行原始碼的安裝

go install github.com/labstack/echo
 

在安裝後如果產生了歸檔檔案（以“.a”為副檔名的檔案），就會放進該工作區的pkg子目錄；如果產生了可執行檔案，就可能會放進該工作區的bin子目錄。

上面該命令在安裝後生成的歸檔檔案的相對目錄就是 github.com/labstack， 檔名為echo.a。

除此之外，歸檔檔案的相對目錄與pkg目錄之間還有一級目錄，叫做平臺相關目錄。平臺相關目錄的名稱是由build（也稱“構建”）的目標作業系統、下劃線和目標計算架構的代號組成的。

比如，構建某個程式碼包時的目標作業系統是Linux，目標計算架構是64位的，那麼對應的平臺相關目錄就是linux_amd64。

程式碼塊中的重名變數

我們來看一下下面的程式碼：

var block = "package"

func main() {
    block := "function"
    {
        block := "inner"
        fmt.Printf("The block is %s.\n", block)
    }
    fmt.Printf("The block is %s.\n", block)
    blockFun()
}

這個命令原始碼⽂件中有四個程式碼塊，它們是：全域程式碼塊、main包代表的程式碼塊、main函式代表的程式碼塊，以及在main函 數中的⼀個⽤花括號包起來的程式碼塊。

如果執行該程式碼，那麼會得到如下結果：

The block is inner.
The block is function.

在go中，首先，程式碼引⽤變數的時候總會最優先查詢當前程式碼塊中的那個變數。

其次，如果當前程式碼塊中沒有宣告以此為名的變數，那麼程式會沿著程式碼塊的巢狀關係，從直接包含當前程式碼塊的那個代 碼塊開始，⼀層⼀層地查詢。

⼀般情況下，程式會⼀直查到當前程式碼包代表的程式碼塊。如果仍然找不到，那麼Go語⾔的編譯器就會報錯了。

所以上面的例子中，main程式碼塊首先無法引用到最內層程式碼塊中的變數，最內層的程式碼塊也會優先去找自己程式碼塊的變數。

需要注意一點的是，在不同的程式碼塊中，變數的名字可以相同但是型別可以不同的。

其實如果使用過java，就會發現這些都和java的變數申明是一樣的。

變數的型別

判斷變數型別

在java中，我們可以用instanceof來判斷型別，在go中要稍微麻煩一點，具體的如下：

func main() {
    container := map[int]string{0: "zero", 1: "one", 2: "two"}
    fmt.Printf("The element is %q.\n", container[1])
    
    value2, ok2 := interface{}(container).(map[int]string)
    value1,   ok1 := interface{}(container).([]string)
    fmt.Println(value1)
    fmt.Println(value2)
    if !(ok1 || ok2) {
        fmt.Printf("Error: unsupported container type: %T\n", container)
        return
    } 
}

也就是說需要通過interface{}(container).(map[int]string)這樣的一句表示式來實現判斷型別。

它包括了⽤來把container變數的值轉換為空接⼝值的interface{}(container)。 以及⼀個⽤於判斷前者的型別是否為map型別 map[int]string 的 .(map[int]string)。

這個表示式返回兩個變數，ok代表是否判斷成功，如果為true，那麼被判斷的值將會被自動轉換為map[int]string，否則value將被賦 予nil（即“空”）。

強制型別轉換

我們一般可以通過如下的方式實現型別轉換：

    var srcInt = int16(-255)
    dstInt := int8(srcInt)
    fmt.Println(dstInt)

在上面的型別轉換中需要注意的是，這裡是範圍大的型別轉換成範圍小的型別，Go語⾔會把在較⾼ 位置（或者說最左邊位置）上的8位⼆進位制數直接截掉，所以dstInt的值就是1。

類似的快⼑斬亂麻規則還有：當把⼀個浮點數型別的值轉換為整數型別值時，前者的⼩數部分會被全部截掉。

所以在型別轉換的時候要時刻提防類型範圍的問題。

類型別名和潛在型別

別名型別與其源型別的區別恐怕只是在名稱上，它們 是完全相同的。

type MyString = string

定義新的型別，這個型別會不同於其他任何型別。

type MyString2 string // 注意，這⾥沒有等號。

如果兩個值潛在型別相同，卻屬於不同型別，它們之間是可以進⾏型別轉換的。如下：

type MyString string
str := "BCD"
myStr1 := MyString(str)
myStr2 := MyString("A" + str)

但是兩個型別的潛在型別相同，它們的值之間也不能進⾏判等或⽐較，它們的變數之間也不能賦值。如下：

type MyString2 string
str := "BCD"
myStr2 := MyString2(str)

//myStr2 = str // 這裡的賦值不合法，會引發編譯錯誤。

//fmt.Printf("%T(%q) == %T(%q): %v\n",
        //  str, str, myStr2, myStr2, str == myStr2)  // 這裡的判等不合法，會引發編譯錯誤。 

對於集合類的型別[]MyString2與[]string來說是不可以進⾏型別轉換和比較的，因為[]MyString2與[]string的潛在型別不 同，分別是MyString2和string。如下：

type MyString string
strs := []string{"E", "F", "G"}
var myStrs []MyString
//myStrs := []MyString(strs) // 這裡的型別轉換不合法，會引發編譯錯誤。

管道channel

通道型別的值本身就是併發安全的，這也是Go語⾔⾃帶的、唯⼀⼀個可以滿⾜併發安全性的型別。

當容量為0時，我們可以稱通道為⾮緩衝通道，也就是不帶緩衝的通道。⽽當容量⼤於0時，我們可以稱為緩衝通道，也就是 帶有緩衝的通道。

⼀個通道相當於⼀個先進先出（FIFO）的佇列。也就是說，通道中的各個元素值都是嚴格地按照發送的順序排列的，先被髮 送通道的元素值⼀定會先被接收。元素值的傳送和接收都需要⽤到操作符<-。我們也可以叫它接送操作符。⼀個左尖括號緊 接著⼀個減號形象地代表了元素值的傳輸⽅向。

func main() {
    ch1 := make(chan int, 3)
  //往channel中放入元素
    ch1 <- 2
    ch1 <- 1
    ch1 <- 3
  //往channel中獲取元素
    elem1 := <-ch1
    fmt.Printf("The first element received from channel ch1: %v\n",
        elem1)
}

基本特性

1. 對於同⼀個通道，傳送操作之間是互斥的，接收操作之間也是互斥的。

在同⼀時刻，Go語⾔的運⾏時系統（以下簡稱運⾏時系統）只會執⾏對同⼀個通道的任意個發 送操作中的某⼀個。直到這個元素值被完全複製進該通道之後，其他針對該通道的傳送操作才可能被執⾏。

類似的，在同⼀時刻，運⾏時系統也只會執⾏，對同⼀個通道的任意個接收操作中的某⼀個。

另外，對於通道中的同⼀個元素值來說，傳送操作和接收操作之間也是互斥的。例如，雖然會出現，正在被複制進通道但還未 複製完成的元素值，但是這時它絕不會被想接收它的⼀⽅看到和取⾛。

需要注意的是：進⼊通道的並不是在接收操作符右邊的那個元素 值，⽽是它的副本。

1. 傳送操作和接收操作中對元素值的處理都是不可分割的。
   如傳送操作要麼還沒複製元素值，要麼已經複製完畢，絕不會出現只複製了⼀部分的情況。

2. 傳送操作在完全完成之前會被阻塞。接收操作也是如此。
   傳送操作包括了“複製元素值”和“放置副本到通道內部”這兩個步驟。

在這兩個步驟完全完成之前，發起這個傳送操作的那句程式碼會⼀直阻塞在那⾥。也就是說，在它之後的程式碼不會有執⾏的機 會，直到這句程式碼的阻塞解除。

⻓時間的阻塞

1. 緩衝通道
   如果通道已滿，那麼對它的所有傳送操作都會被阻塞，直到通道中有元素值被接收⾛。

由於傳送操作在這種情況下被阻塞後，它們所在的goroutine會順序地進⼊通道內部的傳送等待佇列，所以通知的順序總是公平的。

    // 示例1。
    ch1 := make(chan int, 1)
    ch1 <- 1
    //ch1 <- 2 // 通道已滿，因此這裡會造成阻塞。

    // 示例2。
    ch2 := make(chan int, 1)
    //elem, ok := <-ch2 // 通道已空，因此這裡會造成阻塞。
    //_, _ = elem, ok
    ch2 <- 1

1. ⾮緩衝通道

⽆論是傳送操作還是接收操作，⼀開始執⾏就會被阻塞，直到配對的操作也開始執⾏，才 會繼續傳遞。由此可⻅，⾮緩衝通道是在⽤同步的⽅式傳遞資料。也就是說，只有收發雙⽅對接上了，資料才會被傳遞。

    ch1 := make(chan int )
    ch1 <- 10 
    fmt.Println("End." )//這裡會造成阻塞。

關閉通道

對於⼀個已初始化的通道來說，如果通道一旦關閉，再對它進⾏傳送操作，就會 引發panic。

如果試圖關閉⼀個已經關閉了的通道，也會引發panic。

所以我們在關閉通道的時候應當讓傳送方做這件事，接收操作是可以感知到通道的關閉的，並能夠安全退出。

如果通道關閉時，⾥⾯還有元素值未被取出，那麼接收表示式的第⼀個結果，仍會是通道中的某⼀個元素值，⽽第⼆個 結果值⼀定會是true。

func main() {
    ch1 := make(chan int, 2)
    // 傳送方。
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Printf("Sender: sending element %v...\n", i)
            ch1 <- i
        }
        fmt.Println("Sender: close the channel...")
        close(ch1)
    }()

    // 接收方。
    for {
        elem, ok := <-ch1
        if !ok {
            fmt.Println("Receiver: closed channel")
            break
        }
        fmt.Printf("Receiver: received an element: %v\n", elem)
    }

    fmt.Println("End.")
}

單向通道

如下，這表示了這個通道是單向的，並且只能發⽽不能收。

var uselessChan = make(chan<- int, 1)

單向通道最主要的⽤途就是約束其他程式碼的⾏為。
例如：

func main() {
    // 初始化一個容量為3的通道
    intChan1 := make(chan int, 3)
    //將通道傳入到函式中
    SendInt(intChan1)
}
//使用單向通道限制這個函式只能放入元素到通道中
func SendInt(ch chan<- int) {
    ch <- rand.Intn(1000)
}

在SendInt函式中的程式碼只能 向引數ch傳送元素值，⽽不能從它那⾥接收元素值。這就起到了約束函式⾏為的作⽤。

同樣單通道也可以作為函式的返回值：

func main() { 
    intChan2 := getIntChan() 
    for elem := range intChan2 {
        fmt.Printf("The element in intChan2: %v\n", elem)
    }
}

func getIntChan() <-chan int {
    num := 5
    ch := make(chan int, num)
    for i := 0; i < num; i++ {
        ch <- i
    }
    close(ch)
    return ch
}

函式getIntChan會返回⼀個<-chan int型別的通道，這就意味著得到該通道的程式，只能從通道中接收元素值。

select多路選擇

select語句與通道聯⽤

select語句只能與通道聯⽤，它⼀般由若⼲個分⽀組成。每次執⾏這種語句的時候，⼀般只有⼀個分⽀中的程式碼會被運⾏。

我們通過下面的例子來展示：

func example1() {
    // 準備好幾個通道。
    intChannels := [3]chan int{
        make(chan int, 1),
        make(chan int, 1),
        make(chan int, 1),
    }
    // 隨機選擇一個通道，並向它傳送元素值。
    index := rand.Intn(3)
    fmt.Printf("The index: %d\n", index)
    intChannels[index] <- index
    // 哪一個通道中有可取的元素值，哪個對應的分支就會被執行。
    select {
    case <-intChannels[0]:
        fmt.Println("The first candidate case is selected.")
    case <-intChannels[1]:
        fmt.Println("The second candidate case is selected.")
    case elem := <-intChannels[2]:
        fmt.Printf("The third candidate case is selected, the element is %d.\n", elem)
    default:
        fmt.Println("No candidate case is selected!")
    }
}

在使用select語句中，需要注意：

1. 如果像上述示例那樣加⼊了預設分⽀，那麼⽆論涉及通道操作的表示式是否有阻塞，select語句都不會被阻塞。如果那 ⼏個表示式都阻塞了，或者說都沒有滿⾜求值的條件，那麼預設分⽀就會被選中並執⾏。
2. 如果沒有加⼊預設分⽀，那麼⼀旦所有的case表示式都沒有滿⾜求值條件，那麼select語句就會被阻塞。直到⾄少有⼀ 個case表示式滿⾜條件為⽌。
3. select語句只能對其中的每⼀個case表示式各求值⼀次。
4. select語句包含的候選分⽀中的case表示式都會在該語句執⾏開始時先被求值，並且求值的順序是依從程式碼編寫的順序 從上到下的。
5. 對於每⼀個case表示式，如果其中的傳送表示式或者接收表示式在被求值時，相應的操作正處於阻塞狀態，那麼對 該case表示式的求值就是不成功的。
6. 如果select語句發現同時有多個候選分⽀滿⾜選擇條件，那麼它就會⽤⼀種偽隨機的演算法在這些分⽀中選擇⼀個並執⾏。

超時控制

select 裡面會根據兩個case的返回時間來選擇執行，哪個先返回哪個就先執行，所以利用這個功能，可以實現超時返回。

func TestSelect(t *testing.T) {
    //select 裡面會根據兩個case的返回時間來選擇執行
    //哪個先返回哪個就先執行
    //所以利用這個功能，可以實現超時返回
    select {
    case ret:=<-AsyncService():
        t.Log(ret)
    case <-time.After(time.Microsecond*100):
        t.Error("time out")
    }
}

func AsyncService() chan string {
    retCh := make(chan string,1)
    go func() {
        ret := service()
        fmt.Println("return result.")
        retCh <- ret
        fmt.Println("service exited.")
    }()
    return retCh
}

函式

接受其他的函式作為引數傳⼊

我們可以先申明一個函式型別：

type operate func(x, y int) int

然後將這個函式當做引數傳入到函式內

func calculate(x int, y int, op operate) (int, error) {
    if op == nil {
        return 0, errors.New("invalid operation")
    }
    return op(x, y), nil
}

閉包

可以借閉包在程式運⾏的過程中，根據需要⽣成功能不同的函式，繼⽽影響後續的程式⾏為。

例如：

type calculateFunc func(x int, y int) (int, error)

func genCalculator(op operate) calculateFunc {
    return func(x int, y int) (int, error) {
        if op == nil {
            return 0, errors.New("invalid operation")
        }
        return op(x, y), nil
    }
}

func main() {  
    x, y = 56, 78
    add := genCalculator(op)
    result, err = add(x, y)
    fmt.Printf("The result: %d (error: %v)\n",
        result, err)
}

引數值在函式中傳遞

分為兩種型別來處理，值型別和引用型別

1. 值型別
   所有傳給函式的引數值都會被複制，函式在其內部使⽤的並不是引數值的原 值，⽽是它的副本。

如下：

func main() {
    // 示例1。
    array1 := [3]string{"a", "b", "c"}
    fmt.Printf("The array: %v\n", array1)
    array2 := modifyArray(array1)
    fmt.Printf("The modified array: %v\n", array2)
    fmt.Printf("The original array: %v\n", array1)
    fmt.Println()
 
}

// 示例1。
func modifyArray(a [3]string) [3]string {
    a[1] = "x"
    return a
}

返回的是：

The array: [a b c]
The modified array: [a x c]
The original array: [a b c]

由於陣列是值型別，所以每⼀次複製都會拷⻉它，以及它的所有元素值。我在modify函式中修改的只是原陣列的副本⽽已， 並不會對原陣列造成任何影響。

1. 引用型別
   對於引⽤型別，⽐如：切⽚、字典、通道，像上⾯那樣複製它們的值，只會拷⻉它們本身⽽已，並不會拷⻉它們引⽤的 底層資料。也就是說，這時只是淺表複製，⽽不是深層複製。

以切⽚值為例，如此複製的時候，只是拷⻉了它指向底層陣列中某⼀個元素的指標，以及它的⻓度值和容量值，⽽它的底層數 組並不會被拷⻉。

如下：

func main() { 
    slice1 := []string{"x", "y", "z"}
    fmt.Printf("The slice: %v\n", slice1)
    slice2 := modifySlice(slice1)
    fmt.Printf("The modified slice: %v\n", slice2)
    fmt.Printf("The original slice: %v\n", slice1)
    fmt.Println() 
}
func modifySlice(a []string) []string {
    a[1] = "i"
    return a
}

返回：

The slice: [x y z]
The modified slice: [x i z]
The original slice: [x i z]

由於類modifySlice傳入的是一個指標的引用，所以當指標所指向的底層陣列發生變化，那麼原值就會發生變化。

1. 引用型別和值型別結合的型別

如下：

func main() {  
    complexArray1 := [3][]string{
        []string{"d", "e", "f"},
        []string{"g", "h", "i"},
        []string{"j", "k", "l"},
    }
    fmt.Printf("The complex array: %v\n", complexArray1)
    complexArray2 := modifyComplexArray(complexArray1)
    fmt.Printf("The modified complex array: %v\n", complexArray2)
    fmt.Printf("The original complex array: %v\n", complexArray1)
}

func modifyComplexArray(a [3][]string) [3][]string {
    a[1][1] = "s"
    a[2] = []string{"o", "p", "q"}
    return a
}

返回：

The complex array: [[d e f] [g h i] [j k l]]
The modified complex array: [[d e f] [g s i] [o p q]]
The original complex array: [[d e f] [g s i] [j k l]]

實際上還是和上面的一樣的理論，傳入modifyComplexArray方法的陣列是複製的，但是數組裡面的元素傳的是引用，所以直接修改引用的切片值會影響到原來的值，但是直接以這樣的方式a[2] = []string{"o", "p", "q"}新建了一個數組則不會改變