Go 系列教程-4 基礎知識

阿新 • • 發佈：2018-12-15

Go 系列教程 —— 11. 陣列和切片

陣列

陣列是同一型別元素的集合。例如，整數集合 5,8,9,79,76 形成一個數組。Go 語言中不允許混合不同型別的元素，例如包含字串和整數的陣列。（譯者注：當然，如果是 interface{} 型別陣列，可以包含任意型別）

陣列的宣告

一個數組的表示形式為 [n]T。n 表示陣列中元素的數量，T 代表每個元素的型別。元素的數量 n 也是該型別的一部分（稍後我們將詳細討論這一點）。

可以使用不同的方式來宣告陣列，讓我們一個一個的來看。

package main

import (
    "fmt"
)

func main() {
    var a [3]int //int array with length 3
    fmt.Println(a)
}

線上執行程式

var a[3]int 聲明瞭一個長度為 3 的整型陣列。陣列中的所有元素都被自動賦值為陣列型別的零值。 在這種情況下，a 是一個整型陣列，因此 a 的所有元素都被賦值為 0，即 int 型的零值。執行上述程式將輸出 [0 0 0]。

陣列的索引從 0 開始到 length - 1 結束。讓我們給上面的陣列賦值。

package main

import (
    "fmt"
)

func main() {
    var a [3]int //int array with length 3
    a[0] = 12 // array index starts at 0
    a[1] = 78
    a[2] = 50
    fmt.Println(a)
}

線上執行程式

a[0] 將值賦給陣列的第一個元素。該程式將輸出 [12 78 50]。

讓我們使用 簡略宣告 來建立相同的陣列。

package main

import (
    "fmt"
)

func main() {
    a := [3]int{12, 78, 50} // short hand declaration to create array
    fmt.Println(a)
}

線上執行程式

上面的程式將會列印相同的輸出 [12 78 50]。

在簡略宣告中，不需要將陣列中所有的元素賦值。

package main

import (
    "fmt"
)

func main() {
    a := [3]int{12} 
    fmt.Println(a)
}

線上執行程式

在上述程式中的第 8 行 a := [3]int{12} 宣告一個長度為 3 的陣列，但只提供了一個值 12，剩下的 2 個元素自動賦值為 0。這個程式將輸出 [12 0 0]。

你甚至可以忽略宣告陣列的長度，並用 ... 代替，讓編譯器為你自動計算長度，這在下面的程式中實現。

package main

import (
    "fmt"
)

func main() {
    a := [...]int{12, 78, 50} // ... makes the compiler determine the length
    fmt.Println(a)
}

線上執行程式

陣列的大小是型別的一部分。因此 [5]int 和 [25]int 是不同型別。陣列不能調整大小，不要擔心這個限制，因為 slices 的存在能解決這個問題。

package main

func main() {
    a := [3]int{5, 78, 8}
    var b [5]int
    b = a // not possible since [3]int and [5]int are distinct types
}

線上執行程式

在上述程式的第 6 行中, 我們試圖將型別 [3]int 的變數賦給型別為 [5]int 的變數，這是不允許的，因此編譯器將丟擲錯誤 main.go:6: cannot use a (type [3]int) as type [5]int in assignment。

陣列是值型別

Go 中的陣列是值型別而不是引用型別。這意味著當陣列賦值給一個新的變數時，該變數會得到一個原始陣列的一個副本。如果對新變數進行更改，則不會影響原始陣列。

package main

import "fmt"

func main() {
    a := [...]string{"USA", "China", "India", "Germany", "France"}
    b := a // a copy of a is assigned to b
    b[0] = "Singapore"
    fmt.Println("a is ", a)
    fmt.Println("b is ", b) 
}

線上執行程式

在上述程式的第 7 行，a 的副本被賦給 b。在第 8 行中，b 的第一個元素改為 Singapore。這不會在原始陣列 a 中反映出來。該程式將輸出,

a is [USA China India Germany France]  
b is [Singapore China India Germany France]

同樣，當陣列作為引數傳遞給函式時，它們是按值傳遞，而原始陣列保持不變。

package main

import "fmt"

func changeLocal(num [5]int) {
    num[0] = 55
    fmt.Println("inside function ", num)
}
func main() {
    num := [...]int{5, 6, 7, 8, 8}
    fmt.Println("before passing to function ", num)
    changeLocal(num) //num is passed by value
    fmt.Println("after passing to function ", num)
}

線上執行程式

在上述程式的 13 行中, 陣列 num 實際上是通過值傳遞給函式 changeLocal，陣列不會因為函式呼叫而改變。這個程式將輸出,

before passing to function  [5 6 7 8 8]
inside function  [55 6 7 8 8]
after passing to function  [5 6 7 8 8]

陣列的長度

通過將陣列作為引數傳遞給 len 函式，可以得到陣列的長度。

package main

import "fmt"

func main() {
    a := [...]float64{67.7, 89.8, 21, 78}
    fmt.Println("length of a is",len(a))
}

線上執行程式

上面的程式輸出為 length of a is 4。

使用 range 迭代陣列

for 迴圈可用於遍歷陣列中的元素。

package main

import "fmt"

func main() {
    a := [...]float64{67.7, 89.8, 21, 78}
    for i := 0; i < len(a); i++ { // looping from 0 to the length of the array
        fmt.Printf("%d th element of a is %.2f\n", i, a[i])
    }
}

線上執行程式

上面的程式使用 for 迴圈遍歷陣列中的元素，從索引 0 到 length of the array - 1。這個程式執行後打印出，

0 th element of a is 67.70  
1 th element of a is 89.80  
2 th element of a is 21.00  
3 th element of a is 78.00

Go 提供了一種更好、更簡潔的方法，通過使用 for 迴圈的 range 方法來遍歷陣列。range 返回索引和該索引處的值。讓我們使用 range 重寫上面的程式碼。我們還可以獲取陣列中所有元素的總和。

package main

import "fmt"

func main() {
    a := [...]float64{67.7, 89.8, 21, 78}
    sum := float64(0)
    for i, v := range a {//range returns both the index and value
        fmt.Printf("%d the element of a is %.2f\n", i, v)
        sum += v
    }
    fmt.Println("\nsum of all elements of a",sum)
}

線上執行程式

上述程式的第 8 行 for i, v := range a 利用的是 for 迴圈 range 方式。它將返回索引和該索引處的值。我們列印這些值，並計算陣列 a 中所有元素的總和。程式的 輸出是，

0 the element of a is 67.70
1 the element of a is 89.80
2 the element of a is 21.00
3 the element of a is 78.00

sum of all elements of a 256.5

如果你只需要值並希望忽略索引，則可以通過用 _ 空白識別符號替換索引來執行。

for _, v := range a { // ignores index  
}

上面的 for 迴圈忽略索引，同樣值也可以被忽略。

多維陣列

到目前為止我們建立的陣列都是一維的，Go 語言可以建立多維陣列。

package main

import (
    "fmt"
)

func printarray(a [3][2]string) {
    for _, v1 := range a {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
}

func main() {
    a := [3][2]string{
        {"lion", "tiger"},
        {"cat", "dog"},
        {"pigeon", "peacock"}, // this comma is necessary. The compiler will complain if you omit this comma
    }
    printarray(a)
    var b [3][2]string
    b[0][0] = "apple"
    b[0][1] = "samsung"
    b[1][0] = "microsoft"
    b[1][1] = "google"
    b[2][0] = "AT&T"
    b[2][1] = "T-Mobile"
    fmt.Printf("\n")
    printarray(b)
}

線上執行程式

在上述程式的第 17 行，用簡略語法宣告一個二維字串陣列 a 。20 行末尾的逗號是必需的。這是因為根據 Go 語言的規則自動插入分號。至於為什麼這是必要的，如果你想了解更多，請閱讀https://golang.org/doc/effective_go.html#semicolons。

另外一個二維陣列 b 在 23 行宣告，字串通過每個索引一個一個新增。這是另一種初始化二維陣列的方法。

第 7 行的 printarray 函式使用兩個 range 迴圈來列印二維陣列的內容。上述程式的 輸出是

lion tiger
cat dog
pigeon peacock

apple samsung
microsoft google
AT&T T-Mobile

這就是陣列，儘管陣列看上去似乎足夠靈活，但是它們具有固定長度的限制，不可能增加陣列的長度。這就要用到切片了。事實上，在 Go 中，切片比傳統陣列更常見。

切片

切片是由陣列建立的一種方便、靈活且功能強大的包裝（Wrapper）。切片本身不擁有任何資料。它們只是對現有陣列的引用。

建立一個切片

帶有 T 型別元素的切片由 []T 表示

package main

import (
    "fmt"
)

func main() {
    a := [5]int{76, 77, 78, 79, 80}
    var b []int = a[1:4] // creates a slice from a[1] to a[3]
    fmt.Println(b)
}

線上執行程式

使用語法 a[start:end] 建立一個從 a 陣列索引 start 開始到 end - 1 結束的切片。因此，在上述程式的第 9 行中, a[1:4] 從索引 1 到 3 建立了 a 陣列的一個切片表示。因此, 切片 b 的值為 [77 78 79]。

讓我們看看另一種建立切片的方法。

package main

import (  
    "fmt"
)

func main() {  
    c := []int{6, 7, 8} // creates and array and returns a slice reference
    fmt.Println(c)
}

線上執行程式

在上述程式的第 9 行，c：= [] int {6，7，8} 建立一個有 3 個整型元素的陣列，並返回一個儲存在 c 中的切片引用。

切片的修改

切片自己不擁有任何資料。它只是底層陣列的一種表示。對切片所做的任何修改都會反映在底層陣列中。

package main

import (
    "fmt"
)

func main() {
    darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
    dslice := darr[2:5]
    fmt.Println("array before", darr)
    for i := range dslice {
        dslice[i]++
    }
    fmt.Println("array after", darr)
}

線上執行程式

在上述程式的第 9 行，我們根據陣列索引 2,3,4 建立一個切片 dslice。for 迴圈將這些索引中的值逐個遞增。當我們使用 for 迴圈列印陣列時，我們可以看到對切片的更改反映在陣列中。該程式的輸出是

array before [57 89 90 82 100 78 67 69 59]  
array after [57 89 91 83 101 78 67 69 59]

當多個切片共用相同的底層陣列時，每個切片所做的更改將反映在陣列中。

package main

import (
    "fmt"
)

func main() {
    numa := [3]int{78, 79 ,80}
    nums1 := numa[:] // creates a slice which contains all elements of the array
    nums2 := numa[:]
    fmt.Println("array before change 1", numa)
    nums1[0] = 100
    fmt.Println("array after modification to slice nums1", numa)
    nums2[1] = 101
    fmt.Println("array after modification to slice nums2", numa)
}

線上執行程式

在 9 行中，numa [:] 缺少開始和結束值。開始和結束的預設值分別為 0 和 len (numa)。兩個切片 nums1 和 nums2 共享相同的陣列。該程式的輸出是

array before change 1 [78 79 80]  
array after modification to slice nums1 [100 79 80]  
array after modification to slice nums2 [100 101 80]

從輸出中可以清楚地看出，當切片共享同一個陣列時，每個所做的修改都會反映在陣列中。

切片的長度和容量

切片的長度是切片中的元素數。切片的容量是從建立切片索引開始的底層陣列中元素數。

讓我們寫一段程式碼來更好地理解這點。

package main

import (
    "fmt"
)

func main() {
    fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
    fruitslice := fruitarray[1:3]
    fmt.Printf("length of slice %d capacity %d", len(fruitslice), cap(fruitslice)) // length of is 2 and capacity is 6
}

線上執行程式

在上面的程式中，fruitslice 是從 fruitarray 的索引 1 和 2 建立的。因此，fruitlice 的長度為 2。

fruitarray 的長度是 7。fruiteslice 是從 fruitarray 的索引 1 建立的。因此, fruitslice 的容量是從 fruitarray 索引為 1開始，也就是說從 orange 開始，該值是 6。因此, fruitslice 的容量為 6。該程式輸出切片的 長度為 2 容量為 6 。

切片可以重置其容量。任何超出這一點將導致程式執行時丟擲錯誤。

package main

import (
    "fmt"
)

func main() {
    fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
    fruitslice := fruitarray[1:3]
    fmt.Printf("length of slice %d capacity %d\n", len(fruitslice), cap(fruitslice)) // length of is 2 and capacity is 6
    fruitslice = fruitslice[:cap(fruitslice)] // re-slicing furitslice till its capacity
    fmt.Println("After re-slicing length is",len(fruitslice), "and capacity is",cap(fruitslice))
}

線上執行程式

在上述程式的第 11 行中，fruitslice 的容量是重置的。以上程式輸出為，

length of slice 2 capacity 6 
After re-slicing length is 6 and capacity is 6

使用 make 建立一個切片

func make（[]T，len，cap）[]T 通過傳遞型別，長度和容量來建立切片。容量是可選引數, 預設值為切片長度。make 函式建立一個數組，並返回引用該陣列的切片。

package main

import (
    "fmt"
)

func main() {
    i := make([]int, 5, 5)
    fmt.Println(i)
}

線上執行程式

使用 make 建立切片時預設情況下這些值為零。上述程式的輸出為 [0 0 0 0 0]。

追加切片元素

正如我們已經知道陣列的長度是固定的，它的長度不能增加。切片是動態的，使用 append 可以將新元素追加到切片上。append 函式的定義是 func append（s[]T，x ... T）[]T。

x ... T 在函式定義中表示該函式接受引數 x 的個數是可變的。這些型別的函式被稱為可變函式。

有一個問題可能會困擾你。如果切片由陣列支援，並且陣列本身的長度是固定的，那麼切片如何具有動態長度。以及內部發生了什麼，當新的元素被新增到切片時，會建立一個新的陣列。現有陣列的元素被複制到這個新陣列中，並返回這個新陣列的新切片引用。現在新切片的容量是舊切片的兩倍。很酷吧 :smile: 。下面的程式會讓你清晰理解。

package main

import (
    "fmt"
)

func main() {
    cars := []string{"Ferrari", "Honda", "Ford"}
    fmt.Println("cars:", cars, "has old length", len(cars), "and capacity", cap(cars)) // capacity of cars is 3
    cars = append(cars, "Toyota")
    fmt.Println("cars:", cars, "has new length", len(cars), "and capacity", cap(cars)) // capacity of cars is doubled to 6
}

線上執行程式

在上述程式中，cars 的容量最初是 3。在第 10 行，我們給 cars 添加了一個新的元素，並把 append(cars, "Toyota") 返回的切片賦值給 cars。現在 cars 的容量翻了一番，變成了 6。上述程式的輸出是

cars: [Ferrari Honda Ford] has old length 3 and capacity 3  
cars: [Ferrari Honda Ford Toyota] has new length 4 and capacity 6

切片型別的零值為 nil。一個 nil 切片的長度和容量為 0。可以使用 append 函式將值追加到 nil 切片。

package main

import (  
    "fmt"
)

func main() {  
    var names []string //zero value of a slice is nil
    if names == nil {
        fmt.Println("slice is nil going to append")
        names = append(names, "John", "Sebastian", "Vinay")
        fmt.Println("names contents:",names)
    }
}

線上執行程式

在上面的程式 names 是 nil，我們已經新增 3 個字串給 names。該程式的輸出是

slice is nil going to append  
names contents: [John Sebastian Vinay]

也可以使用 ... 運算子將一個切片新增到另一個切片。你可以在可變引數函式教程中瞭解有關此運算子的更多資訊。

package main

import (
    "fmt"
)

func main() {
    veggies := []string{"potatoes", "tomatoes", "brinjal"}
    fruits := []string{"oranges", "apples"}
    food := append(veggies, fruits...)
    fmt.Println("food:",food)
}

線上執行程式

在上述程式的第 10 行，food 是通過 append(veggies, fruits...) 建立。程式的輸出為 food: [potatoes tomatoes brinjal oranges apples]。

切片的函式傳遞

我們可以認為，切片在內部可由一個結構體型別表示。這是它的表現形式，

type slice struct {  
    Length        int
    Capacity      int
    ZerothElement *byte
}

切片包含長度、容量和指向陣列第零個元素的指標。當切片傳遞給函式時，即使它通過值傳遞，指標變數也將引用相同的底層陣列。因此，當切片作為引數傳遞給函式時，函式內所做的更改也會在函式外可見。讓我們寫一個程式來檢查這點。

package main

import (
    "fmt"
)

func subtactOne(numbers []int) {
    for i := range numbers {
        numbers[i] -= 2
    }
}
func main() {
    nos := []int{8, 7, 6}
    fmt.Println("slice before function call", nos)
    subtactOne(nos)                               // function modifies the slice
    fmt.Println("slice after function call", nos) // modifications are visible outside
}

線上執行程式

上述程式的行號 17 中，呼叫函式將切片中的每個元素遞減 2。在函式呼叫後列印切片時，這些更改是可見的。如果你還記得，這是不同於陣列的，對於函式中一個數組的變化在函式外是不可見的。上述程式的輸出是，

array before function call [8 7 6]  
array after function call [6 5 4]

多維切片

類似於陣列，切片可以有多個維度。

package main

import (
    "fmt"
)

func main() {  
     pls := [][]string {
            {"C", "C++"},
            {"JavaScript"},
            {"Go", "Rust"},
            }
    for _, v1 := range pls {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
}

線上執行程式

程式的輸出為，

C C++  
JavaScript  
Go Rust

記憶體優化

切片持有對底層陣列的引用。只要切片在記憶體中，陣列就不能被垃圾回收。在記憶體管理方面，這是需要注意的。讓我們假設我們有一個非常大的陣列，我們只想處理它的一小部分。然後，我們由這個陣列建立一個切片，並開始處理切片。這裡需要重點注意的是，在切片引用時陣列仍然存在記憶體中。

一種解決方法是使用 copy 函式 func copy(dst，src[]T)int 來生成一個切片的副本。這樣我們可以使用新的切片，原始陣列可以被垃圾回收。

package main

import (
    "fmt"
)

func countries() []string {
    countries := []string{"USA", "Singapore", "Germany", "India", "Australia"}
    neededCountries := countries[:len(countries)-2]
    countriesCpy := make([]string, len(neededCountries))
    copy(countriesCpy, neededCountries) //copies neededCountries to countriesCpy
    return countriesCpy
}
func main() {
    countriesNeeded := countries()
    fmt.Println(countriesNeeded)
}

線上執行程式

在上述程式的第 9 行，neededCountries := countries[:len(countries)-2 建立一個去掉尾部 2 個元素的切片 countries，在上述程式的 11 行，將 neededCountries 複製到 countriesCpy 同時在函式的下一行返回 countriesCpy。現在 countries 陣列可以被垃圾回收, 因為 neededCountries 不再被引用。

我已經把我們迄今為止所討論的所有概念整理成一個程式。你可以從 github 下載它。

Go 系列教程 —— 12. 可變引數函式

什麼是可變引數函式

可變引數函式是一種引數個數可變的函式。

語法

如果函式最後一個引數被記作 ...T ，這時函式可以接受任意個 T 型別引數作為最後一個引數。

請注意只有函式的最後一個引數才允許是可變的。

通過一些例子理解可變引數函式如何工作

你是否曾經想過 append 函式是如何將任意個引數值加入到切片中的。這樣 append 函式可以接受不同數量的引數。

func append(slice []Type, elems ...Type) []Type

上面是 append 函式的定義。在定義中 elems 是可變引數。這樣 append 函式可以接受可變化的引數。

讓我們建立一個我們自己的可變引數函式。我們將寫一段簡單的程式，在輸入的整數列表裡查詢某個整數是否存在。

package main

import (
    "fmt"
)

func find(num int, nums ...int) {
    fmt.Printf("type of nums is %T\n", nums)
    found := false
    for i, v := range nums {
        if v == num {
            fmt.Println(num, "found at index", i, "in", nums)
            found = true
        }
    }
    if !found {
        fmt.Println(num, "not found in ", nums)
    }
    fmt.Printf("\n")
}
func main() {
    find(89, 89, 90, 95)
    find(45, 56, 67, 45, 90, 109)
    find(78, 38, 56, 98)
    find(87)
}

線上執行程式碼

在上面程式中 func find(num int, nums ...int) 中的 nums 可接受任意數量的引數。在 find 函式中，引數 nums 相當於一個整型切片。

可變引數函式的工作原理是把可變引數轉換為一個新的切片。以上面程式中的第 22 行為例，find 函式中的可變引數是 89，90，95 。 find 函式接受一個 int 型別的可變引數。因此這三個引數被編譯器轉換為一個 int 型別切片 int []int{89, 90, 95} 然後被傳入 find函式。

在第 10 行， for 迴圈遍歷 nums 切片,如果 num 在切片中，則列印 num 的位置。如果 num 不在切片中,則列印提示未找到該數字。

上面程式碼的輸出值如下,

type of nums is []int
89 found at index 0 in [89 90 95]

type of nums is []int
45 found at index 2 in [56 67 45 90 109]

type of nums is []int
78 not found in  [38 56 98]

type of nums is []int
87 not found in  []

在上面程式的第 25 行，find 函式僅有一個引數。我們沒有給可變引數 nums ...int 傳入任何引數。這也是合法的，在這種情況下 nums 是一個長度和容量為 0 的 nil 切片。

給可變引數函式傳入切片

下面例子中，我們給可變引數函式傳入一個切片，看看會發生什麼。

package main

import (
    "fmt"
)

func find(num int, nums ...int) {
    fmt.Printf("type of nums is %T\n", nums)
    found := false
    for i, v := range nums {
        if v == num {
            fmt.Println(num, "found at index", i, "in", nums)
            found = true
        }
    }
    if !found {
        fmt.Println(num, "not found in ", nums)
    }
    fmt.Printf("\n")
}
func main() {
    nums := []int{89, 90, 95}
    find(89, nums)
}

線上執行程式碼

在第 23 行中，我們將一個切片傳給一個可變引數函式。

這種情況下無法通過編譯，編譯器報出錯誤 main.go:23: cannot use nums (type []int) as type int in argument to find 。

為什麼無法工作呢？原因很直接，find 函式的說明如下，

func find(num int, nums ...int)

由可變引數函式的定義可知，nums ...int 意味它可以接受 int 型別的可變引數。

在上面程式的第 23 行，nums 作為可變引數傳入 find 函式。前面我們知道，這些可變引數引數會被轉換為 int 型別切片然後在傳入 find 函式中。但是在這裡 nums 已經是一個 int 型別切片，編譯器試圖在 nums 基礎上再建立一個切片，像下面這樣

find(89, []int{nums})

這裡之所以會失敗是因為 nums 是一個 []int型別而不是 int型別。

那麼有沒有辦法給可變引數函式傳入切片引數呢？答案是肯定的。

有一個可以直接將切片傳入可變引數函式的語法糖，你可以在在切片後加上 ... 字尾。如果這樣做，切片將直接傳入函式，不再建立新的切片

在上面的程式中，如果你將第 23 行的 find(89, nums) 替換為 find(89, nums...) ，程式將成功編譯並有如下輸出

type of nums is []int
89 found at index 0 in [89 90 95]

下面是完整的程式供您參考。

package main

import (
    "fmt"
)

func find(num int, nums ...int) {
    fmt.Printf("type of nums is %T\n", nums)
    found := false
    for i, v := range nums {
        if v == num {
            fmt.Println(num, "found at index", i, "in", nums)
            found = true
        }
    }
    if !found {
        fmt.Println(num, "not found in ", nums)
    }
    fmt.Printf("\n")
}
func main() {
    nums := []int{89, 90, 95}
    find(89, nums...)
}

線上執行程式碼

不直觀的錯誤

當你修改可變引數函式中的切片時，請確保你知道你正在做什麼。

下面讓我們來看一個簡單的例子。

package main

import (
    "fmt"
)

func change(s ...string) {  
    s[0] = "Go"
}

func main() {
    welcome := []string{"hello", "world"}
    change(welcome...)
    fmt.Println(welcome)
}

線上執行程式碼

你認為這段程式碼將輸出什麼呢？如果你認為它輸出 [Go world] 。恭喜你！你已經理解了可變引數函式和切片。如果你猜錯了，那也不要緊，讓我來解釋下為什麼會有這樣的輸出。

在第 13 行，我們使用了語法糖 ... 並且將切片作為可變引數傳入 change 函式。

正如前面我們所討論的，如果使用了 ... ，welcome 切片本身會作為引數直接傳入，不需要再建立一個新的切片。這樣引數 welcome將作為引數傳入 change 函式

在 change 函式中，切片的第一個元素被替換成 Go，這樣程式產生了下面的輸出值

[Go world]

這裡還有一個例子來理解可變引數函式。

package main

import (
    "fmt"
)

func change(s ...string) {
    s[0] = "Go"
    s = append(s, "playground")
    fmt.Println(s)
}

func main() {
    welcome := []string{"hello", "world"}
    change(welcome...)
    fmt.Println(welcome)
}

線上執行程式碼

Go 系列教程 —— 13. Maps

什麼是 map ？

map 是在 Go 中將值（value）與鍵（key）關聯的內建型別。通過相應的鍵可以獲取到值。

如何建立 map ？

通過向 make 函式傳入鍵和值的型別，可以建立 map。make(map[type of key]type of value) 是建立 map 的語法。

personSalary := make(map[string]int)

上面的程式碼建立了一個名為 personSalary 的 map，其中鍵是 string 型別，而值是 int 型別。

map 的零值是 nil。如果你想新增元素到 nil map 中，會觸發執行時 panic。因此 map 必須使用 make 函式初始化。

package main

import (
    "fmt"
)

func main() {  
    var personSalary map[string]int
    if personSalary == nil {
        fmt.Println("map is nil. Going to make one.")
        personSalary = make(map[string]int)
    }
}

線上執行程式

上面的程式中，personSalary 是 nil，因此需要使用 make 方法初始化，程式將輸出 map is nil. Going to make one.。

給 map 新增元素

給 map 新增新元素的語法和陣列相同。下面的程式給 personSalary map 添加了幾個新元素。

package main

import (
    "fmt"
)

func main() {
    personSalary := make(map[string]int)
    personSalary["steve"] = 12000
    personSalary["jamie"] = 15000
    personSalary["mike"] = 9000
    fmt.Println("personSalary map contents:", personSalary)
}

線上執行程式

上面的程式輸出：personSalary map contents: map[steve:12000 jamie:15000 mike:9000]

你也可以在宣告的時候初始化 map。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int {
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("personSalary map contents:", personSalary)
}

線上執行程式

上面的程式聲明瞭 personSalary，並在宣告的同時新增兩個元素。之後又添加了鍵 mike。程式輸出：

personSalary map contents: map[steve:12000 jamie:15000 mike:9000]

鍵不一定只能是 string 型別。所有可比較的型別，如 boolean，interger，float，complex，string 等，都可以作為鍵。關於可比較的型別，如果你想了解更多，請訪問 http://golang.org/ref/spec#Comparison_operators。

獲取 map 中的元素

目前我們已經給 map 添加了幾個元素，現在學習下如何獲取它們。獲取 map 元素的語法是 map[key] 。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    employee := "jamie"
    fmt.Println("Salary of", employee, "is", personSalary[employee])
}

線上執行程式

上面的程式很簡單。獲取並列印員工 jamie 的薪資。程式輸出 Salary of jamie is 15000。

如果獲取一個不存在的元素，會發生什麼呢？map 會返回該元素型別的零值。在 personSalary 這個 map 裡，如果我們獲取一個不存在的元素，會返回 int 型別的零值 0。

package main

import (  
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    employee := "jamie"
    fmt.Println("Salary of", employee, "is", personSalary[employee])
    fmt.Println("Salary of joe is", personSalary["joe"])
}

線上執行程式

上面程式輸出：

Salary of jamie is 15000
Salary of joe is 0

上面程式返回 joe 的薪資是 0。personSalary 中不包含 joe 的情況下我們不會獲取到任何執行時錯誤。

如果我們想知道 map 中到底是不是存在這個 key，該怎麼做：

value, ok := map[key]

上面就是獲取 map 中某個 key 是否存在的語法。如果 ok 是 true，表示 key 存在，key 對應的值就是 value ，反之表示 key 不存在。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    newEmp := "joe"
    value, ok := personSalary[newEmp]
    if ok == true {
        fmt.Println("Salary of", newEmp, "is", value)
    } else {
        fmt.Println(newEmp,"not found")
    }
}

線上執行程式

上面的程式中，第 15 行，joe 不存在，所以 ok 是 false。程式將輸出：

joe not found

遍歷 map 中所有的元素需要用 for range 迴圈。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("All items of a map")
    for key, value := range personSalary {
        fmt.Printf("personSalary[%s] = %d\n", key, value)
    }

}

線上執行程式

上面程式輸出：

All items of a map
personSalary[mike] = 9000
personSalary[steve] = 12000
personSalary[jamie] = 15000

有一點很重要，當使用 for range 遍歷 map 時，不保證每次執行程式獲取的元素順序相同。

刪除 map 中的元素

刪除 map 中 key 的語法是 delete(map, key)。這個函式沒有返回值。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("map before deletion", personSalary)
    delete(personSalary, "steve")
    fmt.Println("map after deletion", personSalary)

}

線上執行程式

上述程式刪除了鍵 "steve"，輸出：

map before deletion map[steve:12000 jamie:15000 mike:9000]
map after deletion map[mike:9000 jamie:15000]

獲取 map 的長度

獲取 map 的長度使用 len 函式。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("length is", len(personSalary))

}

線上執行程式

上述程式中的 len(personSalary) 函式獲取了 map 的長度。程式輸出 length is 3。

Map 是引用型別

和 slices 類似，map 也是引用型別。當 map 被賦值為一個新變數的時候，它們指向同一個內部資料結構。因此，改變其中一個變數，就會影響到另一變數。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("Original person salary", personSalary)
    newPersonSalary := personSalary
    newPersonSalary["mike"] = 18000
    fmt.Println("Person salary changed", personSalary)

}

線上執行程式

上面程式中的第 14 行，personSalary 被賦值給 newPersonSalary。下一行，newPersonSalary 中 mike 的薪資變成了 18000 。personSalary 中 Mike 的薪資也會變成 18000。程式輸出：

Original person salary map[steve:12000 jamie:15000 mike:9000]
Person salary changed map[steve:12000 jamie:15000 mike:18000]

當 map 作為函式引數傳遞時也會發生同樣的情況。函式中對 map 的任何修改，對於外部的呼叫都是可見的。

Map 的相等性

map 之間不能使用 == 操作符判斷，== 只能用來檢查 map 是否為 nil。

package main

func main() {
    map1 := map[string]int{
        "one": 1,
        "two": 2,
    }

    map2 := map1

    if map1 == map2 {
    }
}

線上執行程式

上面程式丟擲編譯錯誤 invalid operation: map1 == map2 (map can only be compared to nil)。

Go 系列教程 —— 14. 字串

由於和其他語言相比，字串在 Go 語言中有著自己特殊的實現，因此在這裡需要被特別提出來。

什麼是字串？

Go 語言中的字串是一個位元組切片。把內容放在雙引號""之間，我們可以建立一個字串。讓我們來看一個建立並列印字串的簡單示例。

package main

import (
    "fmt"
)

func main() {
    name := "Hello World"
    fmt.Println(name)
}

線上執行程式

上面的程式將會輸出 Hello World。

Go 中的字串是相容 Unicode 編碼的，並且使用 UTF-8 進行編碼。

單獨獲取字串的每一個位元組

由於字串是一個位元組切片，所以我們可以獲取字串的每一個位元組。

package main

import (
    "fmt"
)

func printBytes(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
}

線上執行程式

上面程式的第 8 行，len(s) 返回字串中位元組的數量，然後我們用了一個 for 迴圈以 16 進位制的形式列印這些位元組。%x 格式限定符用於指定 16 進位制編碼。上面的程式輸出 48 65 6c 6c 6f 20 57 6f 72 6c 64。這些打印出來的字元是 "Hello World" 以 Unicode UTF-8 編碼的結果。為了更好的理解 go 中的字串，需要對 Unicode 和 UTF-8 有基礎的理解。我推薦閱讀一下 https://naveenr.net/unicode-character-set-and-utf-8-utf-16-utf-32-encoding/ 來理解一下什麼是 Unicode 和 UTF-8。

讓我們稍微修改一下上面的程式，讓它列印字串的每一個字元。

package main

import (
    "fmt"
)

func printBytes(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}


func printChars(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%c ",s[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
}

線上執行程式

在 printChars 方法(第 16 行中)中，%c 格式限定符用於列印字串的字元。這個程式輸出結果是：

48 65 6c 6c 6f 20 57 6f 72 6c 64  
H e l l o   W o r l d

上面的程式獲取字串的每一個字元，雖然看起來是合法的，但卻有一個嚴重的 bug。讓我拆解這個程式碼來看看我們做錯了什麼。

package main

import (
    "fmt"
)

func printBytes(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}

func printChars(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%c ",s[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
    fmt.Printf("\n")
    name = "Señor"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
}

線上執行程式

上面程式碼輸出的結果是：

48 65 6c 6c 6f 20 57 6f 72 6c 64  
H e l l o   W o r l d  
53 65 c3 b1 6f 72  
S e Ã ± o r

在上面程式的第 28 行，我們嘗試輸出 Señor 的字元，但卻輸出了錯誤的 S e Ã ± o r。為什麼程式分割 Hello World 時表現完美，但分割 Señor 就出現了錯誤呢？這是因為 ñ 的 Unicode 程式碼點（Code Point）是 U+00F1。它的 UTF-8 編碼佔用了 c3 和 b1 兩個位元組。它的 UTF-8 編碼佔用了兩個位元組 c3 和 b1。而我們列印字元時，卻假定每個字元的編碼只會佔用一個位元組，這是錯誤的。在 UTF-8 編碼中，一個程式碼點可能會佔用超過一個位元組的空間。那麼我們該怎麼辦呢？rune 能幫我們解決這個難題。

rune

rune 是 Go 語言的內建型別，它也是 int32 的別稱。在 Go 語言中，rune 表示一個程式碼點。程式碼點無論佔用多少個位元組，都可以用一個 rune 來表示。讓我們修改一下上面的程式，用 rune 來列印字元。

package main

import (
    "fmt"
)

func printBytes(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}

func printChars(s string) {
    runes := []rune(s)
    for i:= 0; i < len(runes); i++ {
        fmt.Printf("%c ",runes[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
    fmt.Printf("\n\n")
    name = "Señor"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
}

線上執行程式

在上面程式碼的第 14 行，字串被轉化為一個 rune 切片。然後我們迴圈列印字元。程式的輸出結果是

48 65 6c 6c 6f 20 57 6f 72 6c 64  
H e l l o   W o r l d 

53 65 c3 b1 6f 72  
S e ñ o r

上面的輸出結果非常完美，就是我們想要的結果:)。

字串的 for range 迴圈

上面的程式是一種遍歷字串的好方法，但是 Go 給我們提供了一種更簡單的方法來做到這一點：使用 for range 迴圈。

package main

import (
    "fmt"
)

func printCharsAndBytes(s string) {
    for index, rune := range s {
        fmt.Printf("%c starts at byte %d\n", rune, index)
    }
}

func main() {
    name := "Señor"
    printCharsAndBytes(name)
}

線上執行程式

在上面程式中的第8行，使用 for range 迴圈遍歷了字串。迴圈返回的是是當前 rune 的位元組位置。程式的輸出結果為：

S starts at byte 0  
e starts at byte 1  
ñ starts at byte 2
o starts at byte 4  
r starts at byte 5

從上面的輸出中可以清晰的看到 ñ 佔了兩個位元組:)。

用位元組切片構造字串

package main

import (  
    "fmt"
)

func main() {  
    byteSlice := []byte{0x43, 0x61, 0x66, 0xC3, 0xA9}
    str := string(byteSlice)
    fmt.Println(str)
}

線上執行程式

上面的程式中 byteSlice 包含字串 Café 用 UTF-8 編碼後的 16 進位制位元組。程式輸出結果是 Café。

如果我們把 16 進位制換成對應的 10 進位制值會怎麼樣呢？上面的程式還能工作嗎？讓我們來試一試：

package main

import (  
    "fmt"
)

func main() {  
    byteSlice := []byte{67, 97, 102, 195, 169}//decimal equivalent of {'\x43', '\x61', '\x66', '\xC3', '\xA9'}
    str := string(byteSlice)
    fmt.Println(str)
}

線上執行程式

上面程式的輸出結果也是Café

用 rune 切片構造字串

package main

import (  
    "fmt"
)

func main() {  
    runeSlice := []rune{0x0053, 0x0065, 0x00f1, 0x006f, 0x0072}
    str := string(runeSlice)
    fmt.Println(str)
}

線上執行程式

在上面的程式中 runeSlice 包含字串 Señor的 16 進位制的 Unicode 程式碼點。這個程式將會輸出Señor。

字串的長度

utf8 package 包中的 func RuneCountInString(s string) (n int) 方法用來獲取字串的長度。這個方法傳入一個字串引數然後返回字串中的 rune 的數量。

package main

import (  
    "fmt"
    "unicode/utf8"
)

func length(s string) {  
    fmt.Printf("length of %s is %d\n", s, utf8.RuneCountInString(s))
}
func main() { 
    word1 := "Señor" 
    length(word1)
    word2 := "Pets"
    length(word2)
}

線上執行程式

上面程式的輸出結果是：

length of Señor is 5  
length of Pets is 4

字串是不可變的

Go 中的字串是不可變的。一旦一個字串被建立，那麼它將無法被修改。

package main

import (  
    "fmt"
)

func mutate(s string)string {  
    s[0] = 'a'//any valid unicode character within single quote is a rune 
    return s
}
func main() {  
    h := "hello"
    fmt.Println(mutate(h))
}

線上執行程式

在上面程式中的第 8 行，我們試圖把這個字串中的第一個字元修改為 'a'。由於字串是不可變的，因此這個操作是非法的。所以程式丟擲了一個錯誤 main.go:8: cannot assign to s[0]。

為了修改字串，可以把字串轉化為一個 rune 切片。然後這個切片可以進行任何想要的改變，然後再轉化為一個字串。

package main

import (  
    "fmt"
)

func mutate(s []rune) string {  
    s[0] = 'a' 
    return string(s)
}
func main() {  
    h := "hello"
    fmt.Println(mutate([]rune(h)))
}

線上執行程式

在上面程式的第 7 行，mutate 函式接收一個 rune 切片引數，它將切片的第一個元素修改為 'a'，然後將 rune 切片轉化為字串，並返回該字串。程式的第 13 行呼叫了該函式。我們把 h 轉化為一個 rune 切片，並傳遞給了 mutate。這個程式輸出 aello。

Go 系列教程-4 基礎知識

Go 系列教程 —— 11. 陣列和切片陣列陣列是同一型別元素的集合。例如，整數集合 5,8,9,79,76 形成一個數組。Go 語言中不允許混合不同型別的元素，例如包含字串和整數的陣列。（譯者注：當然，如果是 interface{} 型別陣列，可以包含任意型別）陣列的宣告一

Go 系列教程-5 基礎知識

Go 系列教程 —— 15. 指標什麼是指標？指標是一種儲存變數記憶體地址（Memory Address）的變數。如上圖所示，變數 b 的值為 156，而 b 的記憶體地址為 0x1040a124。變數 a

Go 系列教程-3 基礎知識

Go 系列教程 —— 8. if-else 語句 if 是條件語句。if 語句的語法是 if condition { } 如果 condition 為真，則執行 { 和 } 之間的程式碼。不同於其他語言，例如 C 語

Go 系列教程-2 基礎知識

Go 系列教程 —— 6. 函式（Function）函式是什麼？函式是一塊執行特定任務的程式碼。一個函式是在輸入源基礎上，通過執行一系列的演算法，生成預期的輸出。函式的宣告在 Go 語言中，函式宣告通用語法如下： func functionname(parameterna

Go 系列教程-1 基礎知識

變數是什麼變數指定了某儲存單元（Memory Location）的名稱，該儲存單元會儲存特定型別的值。在 Go 中，有多種語法用於宣告變數。宣告單個變數 var name type 是宣告單個變數的語法。 package main import "f

EJB系列 - 會話Bean基礎知識

java 軟件開發 java ee ejb peretang 本人博客文章網址:https://www.peretang.com/basic-knowledge-of-session-bean/ 什麽是會話有限的時間周期內,客戶端和服務器之間的連接為什麽使用會話

前端系列之HTML基礎知識概述

漸變技術分享 isa select spl 文件上傳右鍵文本標簽 markup 1、什麽是HTML HTML：Hyper Text Markup Language ：超文本標記語言。超文本：功能比普通文本更加強大。標記語言：使用一組標簽對內容進行描述的語言，它不是編程

前端系列之JavaScript基礎知識概述

div spa func 大小寫 doc space 留言布爾 java ?微信公眾號：compassblog 歡迎關註，歡迎轉發，互相學習，共同進步！有任何問題，請後臺留言聯系！ 1、什麽是JavaScript （1）、JavaScript是web上一種功能強大的

Python3學習筆記4 - 基礎知識

src 接口 0.12 lis utf-8 基礎知識需要 pop 布爾今天主要學習Python3的基礎語法知識 1.註釋 python使用#號來表示註釋，在語句前面加上#號，解釋器就知道了這句是註釋 2.代碼縮進 if a > 10: print(a)

k8s系列0--Kubernetes基礎知識

Once 基於輪詢系列 com 多個 href daemon 負載 Kubernetes介紹參考：Kubernetes核心組件解析 Pod是k8s的最小調度單元每個pod有獨立的IP，但是pod的IP是不可靠的，重新調度pod就會改變IP，service概念就是為

Adobe Dimension Essential Training: The Basics Adobe Dimension 基礎教程：基礎知識 Lynda課程中文字幕

Adobe Dimension Essential Training: The Basics 中文字幕 Adobe Dimension 基礎教程：基礎知識中文字幕Adobe Dimension Essential Training: The Basics 對建立3D複合材料感到好

After Effects CC 2019 Essential Training: The Basics After Effects CC 2019基礎教程：基礎知識 Lynda課程中文字幕

After Effects CC 2019 Essential Training: The Basics 中文字幕 After Effects CC 2019基礎教程：基礎知識中文字幕After Effects CC 2019 Essential Training: The Basic

Go 系列教程-10 反射

反射是 Go 語言的高階主題之一。我會盡可能讓它變得簡單易懂。本教程分為如下小節。什麼是反射？為何需要檢查變數，確定變數的型別？ reflect 包 reflect.Type 和 reflect.Value

Go 系列教程-9 頭等函式

什麼是頭等函式？支援頭等函式（First Class Function）的程式語言，可以把函式賦值給變數，也可以把函式作為其它函式的引數或者返回值。Go 語言支援頭等函式的機制。本教程我們會討論頭等函式的語法和用例。匿名函式我們來編寫一個簡

Go 系列教程-8 錯誤處理

Go 系列教程 —— 30. 錯誤處理什麼是錯誤？錯誤表示程式中出現了異常情況。比如當我們試圖開啟一個檔案時，檔案系統裡卻並沒有這個檔案。這就是異常情況，它用一個錯誤來表示。在 Go 中，錯誤一直是很常見的。錯誤用內建的 error 型別來表示

Go 系列教程-7 面向物件

Go 系列教程 —— 26. 結構體取代類 Go 支援面向物件嗎？ Go 並不是完全面向物件的程式語言。Go 官網的 FAQ 回答了 Go 是否是面嚮物件語言，摘錄如下。可以說是，也可以說不是。雖然 Go 有型別和方法，支援面向物件的程式設

Go 系列教程-6 多執行緒併發

Go 系列教程 —— 20. 併發入門 Go 是併發式語言，而不是並行式語言。在討論 Go 如何處理併發之前，我們必須理解何為併發，以及併發與並行的區別。併發是什麼？併發是指立即處理多個任務的能力。一個例子就能很好地說明這一點。我們可以想象一個人正在跑步。假如在他晨跑時，鞋帶突

學習Go 系列教程 —— 1. 介紹與安裝

這是我們 Golang 系列教程的第一個教程。 Golang 是什麼 Go 亦稱為 Golang（譯註：按照 Rob Pike 說法，語言叫做 Go，Golang 只是官方網站的網址），是由谷歌開發的一個開源的編譯型的靜態語言。 Golang 的主要關注點是使得

JAVA轉go系列之語言基礎

和JAVA語言一樣Go語言也是由多個標記組成，可以是關鍵字，識別符號，常量，字串等等 java語言 Go go語言的fmt包就和Java的System一樣都有它強大的功能屬於自帶的包這裡要說一下，System是一個final

Go 系列教程 —— 1. Go語言開發環境搭建詳解

Go語言介紹Go語言是Google於2009年釋出的第二款開源的程式語言。Go語言的特點：準對多處理器應用程式的程式設計進行了優化，使用Go編譯程式可以媲美C或C++的程式碼速度，而且擁有Python解釋語言的簡潔和開發效率。Go語言優勢可以編譯成機器碼，不依賴其他庫靜態型別