Part 11 :數組和切片

歡迎來到 Golang 系列教程，在本教程中我們討論Go的數組和切片

數組

數組是屬於相同類型的元素的集合。例如，整型集合 5,8,9,79 形成一個數組，不同類型的混合值，例如同時包含字符串和整型的數組，在Go中是不允許的。

聲明

數組屬於 T[n] 類型。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] 爲數組的第一個元素賦值。程序會打印[17 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 是不同的類型。由於這個原因，數組不可以調整大小。不要擔心這個限制，因爲 slice 的存在克服了它。

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提供一個更好和簡單的方法來迭代數組，即使用 range 格式的 for 循環。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 是range格式的 for 循環。它同時返回索引和該索引處的值。我們打印該值並計算 數組 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 indes
}

上面的 for 循環忽略索引。類似地值也可以被忽略。

多維數組

目前我們所創建的數組都是一維的。可以創建多維數組。

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 行結尾的逗號是必要的。這是因爲詞法分析器根據簡單的規則自動插入分號。如果你想了解更多爲什麼這是必要的，請閱讀https://golang.org/doc/effective_go.html#semicolons

第 7 行的 printarray 函數使用兩個 for range 循環來打印第 2 組數組的內容。程序輸出

lion tiger  
cat dog  
pigeon peacock 

apple samsung  
microsoft google  
AT&T T-Mobile  

這些就是數據。儘管數組看上去足夠靈活，但是它們有固定長度的限制。不能夠增加數組的長度。所以 slice出現了。其實在Go中。slices 比數組更常見。

Slices

數組是方便的，靈活的和比 數組更有力量的武器。切片本身並不擁有任何數據。它僅僅是存在的數組的索引。

創建切片(slice)

元素類型爲 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]創建一個表示數組 a 索引 1 到 3 的切片。因此切片 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 循環將這索引的值增加 1 。當在 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)
}

在第 8 行，在 num[:] 中，開始和結尾值是消失了。開始和結束的默認值分別是 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 從 fruitearray的索引 1 和 2 被創建。因此 fruitslice 的長度爲 2。

fruitarray 的長度是 7。fruiteslice 從 fruitarray 的索引 1 被創建。因此 fruitslice 的容量是從索引 1 開始的 fruitarray 中的元素，即 orange ，該值是 6。因此 fruitslice 的容量是 6。這個程序輸出 length of slice 2 capacity 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可以通過傳遞 type, length 和 capacity 被用來創建一個切片。capacity 參數是可選的，默認是長度。make 函數創建一個數組返回一個指向它的切片。

package main

import (  
    "fmt"
)

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

當使用 make 創建一個切片時，默認值是零值。上面程序輸出 [0 0 0 0 0]。

附加到切片

正如我們已經知道的，數組被限定到固定長度，他們的長度不可以被增加。切片是動態的，新元素可以使用 append 函數附加到切片。附加函數的定義是 func append(s []T, x ...T) []T。

函數定義中的 x …T 意味着函數參數 x 接受可變數目的參數。這些函數的類型被稱爲 變參函數。

但有一個問題可能會困擾你。如果切片的底層是數組，數組本身是固定長度的，那切片的長度是如何動態的。當新的元素被附加到切片，底層會發生什麼？一個新的數組被創建。已經存在的數組元素被拷貝到新的數組中，併爲新的數組返回一個新的切片引用。新切片的容量是舊切片的兩倍。很酷吧。下面的程序將使事情更清晰。

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 是空的，我們向 names append 3 個字符串。程序的輸出是

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 通過將 fruits 附加給 veggies 被創建。程序的輸出爲 food: [potatoes tomatoes brinjal organes apples]。

將 slice 傳遞給函數

切片可以被認爲是由結構類型在內部表示。這是它的樣子，

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

切片包含 length，capacity 和一個指向數組第0個元素的指針。當切片被傳遞給函數，即使它是通過值傳遞的，指針變量將指向同樣的底層數組。因此當切片作爲參數傳遞給函數，在函數內部修改對於函數外部是可見的。

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。當切片在函數調用之後打印，這些改變是可見的。如果你能想起的話，這和數組是不同的，數組在函數內部修改對於函數外是不可見的。上面程序輸出

slice before function call [8 7 6]  
slice 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] 創建一個 countries 的不含最後兩個元素的切片。在程序的第 11 行將 neededCountries 拷貝給 contriesCpy，並在下面的一行從函數中的返回它。現在 countries 數組可以被垃圾回收，由於 neededCountries 現在不再引用它。

我已經編譯了我們目前爲止所討論的所有概念到一個程序的，你可以從github下載它。

下一教程 - 變參函數