前言

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

在go语言里，切边是一个应用极为广泛的数据对象；所以在学习golang的过程中，一定要好好的掌握切片的相关知识。

4.2.2 切片

Go 语言切片是对数组的抽象。一个slice类型一般写作[]T，其中T代表slice中元素的类型。

slice的语法和数组很像，只是没有固定长度而已。数组和slice之间有着紧密的联系。一个slice是一个轻量级的数据结构，提供了访问数组子序列 （或者全部）元素的功能，slice的**底层引用一个数组对象**。

`slice`(切片)代表变长的序列，序列中每个元素都有相同的类型。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

4.2.2.1 声明切片

你可以声明一个未指定大小的数组来定义切片：

var slice_01 []type

在语法上和上面的数组比较的相似；差别就在于切片不需要说明长度。

也可以使用 make() 函数来创建切片:

var slice_01 []type = make([]type, len) 或为 slice_01 := make([]type, len)

在切片的make声明和初始话的方式中；也可以指定容量，

比如

make([]T, length, capacity)

其中 capacity 为可选参数。通过上面的方式就可以声明和初始话一个容量大小为capacity，当前长度为length的切片，切片的用法如何使用过python语言的话，这个切片的数据类型可以实现的功能基本上和python语言里slice函数的非常的相似

需要说明，slice 并不是数组或数组指针。它通过内部指针和相关属性引⽤数组⽚段，以实现变⻓⽅案。

runtime.h

#runtime.h struct Slice { // must not move anything byte* array; // actual data uintgo len; // number of elements uintgo cap; // allocated number of elements };

以上是golang里slice的源代码片段；可以通过这个slice的结构体源代码的定义，发现在golang里，slice是通过内部属性和指针的方式，来实现了变长的方案。

• 引⽤类型。但⾃⾝是结构体，值拷⻉传递。

• 属性 len 表⽰可⽤元素数量，读写操作不能超过该限制。

• 属性 cap 表⽰最⼤扩张容量，不能超出数组限制。

• 如果 slice == nil，那么 len、cap 结果都等于 0。

4.2.2.2 切片初始化

slice_01 :=[] int {1,2,3 }

通过初始化语句:=直接进行初始化， 其中[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。通过以上语句，实现了初始化slice_01对象为切片对象，并且长度和容量都为3；其中元素依次为1，2，3的int切片。

4.2.2.3 len和cap

切片是可索引的，并且可以由 len() 方法获取长度。切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

x := make([]int,3,5) fmt.Printf("len=%d cap=%d slice=%v**\n**",len(x),cap(x),x) ====OUTPUT==== len=3 cap=5 slice=[0 0 0]

一个切片在未初始化之前默认为 nil，长度为 0，如下：

var x []int fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x) ====OUTPUT==== len=0 cap=0 slice=[]

4.2.2.4 slice

s := arr[startIndex:endIndex]

将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。

s := arr[startIndex:]

默认 endIndex 时将表示一直到arr的最后一个元素。

s := arr[:endIndex]

默认 startIndex 时将表示从 arr 的第一个元素开始。

样例

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} expression slice len cap ------------+----------------------+------+------- data[:6:8] [0 1 2 3 4 5] 6 8 data[5:] [5 6 7 8 9] 5 5 data[:3] [0 1 2] 3 10 data[:] [0 1 2 3 4 5 6 7 8 9] 10 10 data[:11:12] Error

读写操作实际⺫标是底层数组，只需注意索引号的差别。

data := [...]int{0, 1, 2, 3, 4, 5} s := data[2:4] s[0] += 1020 s[1] += 2020 fmt.Println(s) fmt.Println(data)

输出：

[1022 2023] [0 1 1022 2023 3 4 5]

s1 := s[startIndex:endIndex]

通过切片 s 初始化切片 s1。

对于是基于已有 slice 创建新 slice 对象，特别注意要保证切片的 cap 允许范围内调整属性。

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} s1 := s[2:5] // [2 3 4]   len=3 cap=8 s2 := s1[2:6:7] // [4 5 6 7] len=3 cap=5 s3 := s2[3:6] // Error

切片操作后新对象依旧指向原底层数组。

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} s1 := s[2:5] // [2 3 4] s1[2] = 1020 fmt.Println(s1) s2 := s1[2:6] // [1020 5 6 7] s2[0] = 2010 s2[3] = 2020 fmt.Println(s2) fmt.Println(s) ====OUTPUT==== [2 3 1020] [2010 5 6 2020] [2 3 2010] [0 1 2 3 2010 5 6 2020 8 9]

4.2.2.5 append

向 slice 尾部添加数据，返回新的 slice 对象。

s := make([]int, 0, 5) fmt.Printf("%p\n", &s) s2 := append(s, 1) fmt.Printf("%p\n", &s2) fmt.Println(s, s2) ====OUTPUT===== 0xc000004498 0xc0000044c8 [] [1]

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} s := data[:3] s2 := append(s, 100, 200) // 添加多个值。 fmt.Println(data) fmt.Println(s) fmt.Println(s2) ====OUTPUT===== [0 1 2 100 200 5 6 7 8 9] [0 1 2] [0 1 2 100 200]

⼀旦超出原 slice.cap 限制，就会重新分配底层数组，即便原数组并未填满。

data := [...]int{0, 1, 2, 3, 4, 10: 0} s := data[:2:3] s = append(s, 100, 200) // ⼀次 append 两个值，超出 s.cap 限制。 fmt.Println(s, data) // 重新分配底层数组，与原数组⽆关。 fmt.Println(&s[0], &data[0]) // ⽐对底层数组起始指针。 ====OUTPUT===== [0 1 100 200] [0 1 2 3 4 5 6 7 8 9] 0xc0001e21e0 0xc000022af0

从输出结果可以看出，append 后的 s 重新分配了底层数组，并复制数据。如果只追加⼀个值，则不会超过 s.cap 限制，也就不会重新分配

将上面程序改成下面的

data := [...]int{0, 1, 2, 3, 4, 10: 0} s := data[:2:3] s = append(s, 100) fmt.Println(s, data) fmt.Println(&s[0], &data[0]) s = append(s, 200)   fmt.Println(s, data) // 重新分配底层数组，与原数组⽆关。 fmt.Println(&s[0], &data[0]) // ⽐对底层数组起始指针。 ====OUTPUT===== [0 1 100] [0 1 100 3 4 5 6 7 8 9] 0xc00011e9b0 0xc00011e9b0 [0 1 100 200] [0 1 100 3 4 5 6 7 8 9] 0xc00013dd70 0xc00011e9b0

4.2.2.6 copy

copy 函数可以实现在两个 slice 间复制数据，复制⻓度以 len⼩的为准。两个 slice 可指向同⼀底层数组，允许元素区间重叠。

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} s := data[8:] s2 := data[:5] copy(s2, s) fmt.Println(s2) fmt.Println(data) ====OUTPUT===== [8 9 2 3 4] [8 9 2 3 4 5 6 7 8 9]

4.2.2.7 扩容

当切片的长度超过容量的情况下，切片会进行扩容操作；通常以 2 倍容量重新分配底层数组。在⼤批量添加数据时，建议⼀次性分配⾜够⼤的空间，以减少内存分配和数据复制开销。或初始化⾜够⻓的 len 属性，改⽤索引号进⾏操作。及时释放不再使⽤的 slice 对象，避免持有过期数组，造成 GC ⽆法回收

结束语

在go语言里，切边是一个应用极为广泛的数据对象；所以在学习golang的过程中，一定要好好的掌握切片的相关知识。