在 Go 中串聯兩個切片

  1. 切片宣告
  2. Go 切片的串聯
  3. append() 函式的工作

在 Go 中,切片是一種動態資料結構,用於儲存相同資料型別的多個元素。它們也可以被認為是可變大小的陣列,具有從陣列型別的索引,但是它們的大小不是固定的,因為它們可以調整大小。由於切片本質上是動態的,因此我們可以使用 append 函式將新元素附加到切片或連線兩個或多個切片。

切片宣告

切片的宣告類似於陣列,但未指定大小。

package main

import "fmt"

func main() {
    var Slice1 = []int{1, 2, 3, 4}
    fmt.Printf("Length of Slice: %v\n",len(Slice1))
    fmt.Printf("First Element: %v\n",Slice1[0])
    fmt.Printf("Second Element: %v\n",Slice1[1])
    fmt.Printf("Third Element: %v\n",Slice1[2])
    fmt.Printf("Fourth Element: %v\n",Slice1[3])

}

輸出:

Length of Slice: 4
First Element: 1
Second Element: 2
Third Element: 3
Fourth Element: 4

Go 切片的串聯

我們使用內建的 append() 函式新增元素以將兩個或多個切片一起列出或連線在一起。如果有足夠的容量,則將目標切片以容納新元素。如果沒有足夠的可用容量,則會分配新的基礎並複製內容。最後,append 函式返回更新的切片。

將單個元素附加到切片

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)  
    fmt.Printf("slice_1: %v\n", slice_1)
    fmt.Printf("slice_2: %v\n", slice_2)

}

輸出:

slice_1: [1 2]
slice_2: [1 2 3]

Go 中將多個元素附加到切片

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)
    slice_3 := append(slice_2, 4,5,6)   
    fmt.Printf("slice_3: %v\n", slice_3)

}

輸出:

slice_3: [1 2 3 4 5 6]

連線兩個切片

package main

import "fmt"

func main() {
    var slice_3 = []int{1, 2, 3, 4, 5, 6}
    var slice_4 = []int{7,8}
    
    slice_5 := append(slice_3,slice_4...) 
    fmt.Printf("slice_4: %v\n", slice_4)
    fmt.Printf("slice_5: %v\n", slice_5)

}

輸出:

slice_4: [7 8]
slice_5: [1 2 3 4 5 6 7 8]

一次連線兩個切片時要注意的一個重要點是,在 slice_4 之後的 ... 是必不可少的,因為 append() 是一個可變引數函式,就像其他可變引數函式一樣。... 使你可以從切片將多個引數傳遞給函式。這裡對 slice_4 中的每個元素遞迴呼叫 append 函式。

Go 中將字串追加到位元組片

var slice []byte = append([]byte("abc "), "def"...)
fmt.Printf("slice: %v\n", slice)

輸出:

slice: [97 98 99 32 100 101 102]

在這裡,字元使用 UTF-8 編碼,使用 3 個位元組表示字元的 ASCII 值。切片位元組可以按以下方式轉換回字串:

slice_str := string(slice)
fmt.Printf("String: %v\n", slice_str)

輸出:

Slice: abc def

append() 函式的工作

內建函式 append() 採用一個切片,將所有元素附加到輸入切片的末尾,最後返回級聯的切片。如果目標切片具有足夠的容量,則將切片該切片以容納新的附加元素。但是,如果目的地沒有足夠的容量,則會建立一個新陣列,並將現有切片中存在的元素複製到新陣列中,最後,該函式將返回一個新陣列。

package main

import "fmt"

func main() {

    slice_1 := []int{0, 1, 2}
    fmt.Println("slice_1 : ", slice_1)
    fmt.Println("Capacity of slice_1: ", cap(slice_1))

    res_1 := append(slice_1, 3)
    fmt.Println("res_1 : ", res_1)
    fmt.Println("Capacity of res_1: ", cap(res_1))

    slice_2 := make([]int, 3, 5)  //Create slice_1 with length 3 and capacity 5
    copy(slice_2, []int{0, 1, 2}) //Copy elements into slice_1
    fmt.Println("slice_2 : ", slice_2)
    fmt.Println("Capacity of slice_2: ", cap(slice_2))

    res_2 := append(slice_2, 3)
    fmt.Println("res_2 : ", res_2)
    fmt.Println("Capacity of res_2: ", cap(res_2))

}

輸出:

slice_1 :  [0 1 2]
Capacity of slice_1:  3
res_1 :  [0 1 2 3]
Capacity of res_1:  6
slice_2 :  [0 1 2]
Capacity of slice_2:  5
res_2 :  [0 1 2 3]
Capacity of res_2:  5

這裡的 slice_1 沒有足夠的容量來新增新元素,因此建立了容量為 6 的新片,並將現有片中的所有元素都複製到新建立的片中。

但是,slice_2 具有足夠的容量來新增新元素,因此元素被新增到現有的切片中。

相關文章 - Go Slice

  • 如何從 Go 中的切片 Slice 中刪除元素