在 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