在 Go 中串聯兩個切片
在 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 具有足夠的容量來新增新元素，因此元素被新增到現有的切片中。
Suraj Joshi is a backend software engineer at Matrice.ai.
LinkedIn