迹忆客 专注技术分享

在 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

我们使用内置的 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]

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 函数。

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() 采用一个切片，将所有元素附加到输入切片的末尾，最后返回级联的切片。如果目标切片具有足够的容量，则将切片该切片以容纳新的附加元素。但是，如果目的地没有足够的容量，则会创建一个新数组，并将现有切片中存在的元素复制到新数组中，最后，该函数将返回一个新数组。

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 具有足够的容量来添加新元素，因此元素被添加到现有的切片中。