Go 陣列和切片

阿新 • • 發佈：2021-06-28

11. 陣列和切片

陣列

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

陣列的宣告

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

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

Copy

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 結束。讓我們給上面的陣列賦值。

Copy

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]。

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

Copy

package main

import (
    "fmt"
)

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

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

。

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

Copy

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]。

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

Copy

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 的存在能解決這個問題。

Copy

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

Copy

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 中反映出來。該程式將輸出,

Copy

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

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

Copy

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，陣列不會因為函式呼叫而改變。這個程式將輸出,

Copy

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 函式，可以得到陣列的長度。

Copy

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 迴圈可用於遍歷陣列中的元素。

Copy

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。這個程式執行後打印出，

Copy

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 重寫上面的程式碼。我們還可以獲取陣列中所有元素的總和。

Copy

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 中所有元素的總和。程式的 輸出是，

Copy

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

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

Copy

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

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

多維陣列

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

Copy

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 迴圈來列印二維陣列的內容。上述程式的 輸出是

Copy

lion tiger
cat dog
pigeon peacock

apple samsung
microsoft google
AT&T T-Mobile

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

切片

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

建立一個切片

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

Copy

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]。

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

Copy

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 中的切片引用。

切片的修改

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

Copy

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 迴圈列印陣列時，我們可以看到對切片的更改反映在陣列中。該程式的輸出是

Copy

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

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

Copy

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 共享相同的陣列。該程式的輸出是

Copy

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]

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

切片的長度和容量

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

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

Copy

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 。

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

Copy

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 的容量是重置的。以上程式輸出為，

Copy

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

使用 make 建立一個切片

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

Copy

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 的個數是可變的。這些型別的函式被稱為[可變函式]。

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

Copy

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。上述程式的輸出是

Copy

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 切片。

Copy

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。該程式的輸出是

Copy

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

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

Copy

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]。

切片的函式傳遞

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

Copy

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

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

Copy

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。在函式呼叫後列印切片時，這些更改是可見的。如果你還記得，這是不同於陣列的，對於函式中一個數組的變化在函式外是不可見的。上述[程式]的輸出是，

Copy

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

多維切片

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

Copy

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

程式的輸出為，

Copy

C C++  
JavaScript  
Go Rust

記憶體優化

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

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

Copy

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 不再被引用。

Go 陣列和切片

11. 陣列和切片

陣列

陣列的宣告

陣列是值型別

陣列的長度

使用 range 迭代陣列

多維陣列

切片

建立一個切片

切片的修改

切片的長度和容量

使用 make 建立一個切片

追加切片元素

切片的函式傳遞

多維切片

記憶體優化

Go 陣列和切片

Go語言系列(三)之陣列和切片

Go語言入門系列(三)之陣列和切片

Go 語言陷阱 - 陣列和切片

Go語言基礎四：複雜資料型別之陣列和切片

GOGOUP-8.陣列和切片

大資料開發-Go-陣列，切片

如何在Go中使用切片容量和長度

Go的100天之旅-06陣列和Slice

【轉】go語言筆記——切片函式常見操作，增刪改查和搜尋、排序

Go——包管理，if，迴圈，switch，陣列，切片

Go之陣列、切片、map

go特性-陣列與切片

go特性之陣列與切片的問題

Go語言之陣列與切片基礎

Numpy陣列索引和切片

深入理解go-channel和select的原理

資料結構與演演算法學習：陣列和連結串列

Java如何獲取陣列和字串的長度(length還是length())

python中下標和切片的使用方法解析

Go 陣列和切片

11. 陣列和切片

陣列

陣列的宣告

陣列是值型別

陣列的長度

使用 range 迭代陣列

多維陣列

切片

建立一個切片

切片的修改

切片的長度和容量

使用 make 建立一個切片

追加切片元素

切片的函式傳遞

多維切片

記憶體優化

相關推薦