slice（切片）是 go 里面非常常用的一种数据结构，它代表了一个变长的序列，序列中的每个元素都有相同的数据类型。
一个 slice 类型一般写作 []T，其中 T 代表 slice 中元素的类型；slice 的语法和数组很像，但是 slice 没有固定长度。
数组和切片的区别
数组有确定的长度，而切片的长度不固定，并且可以自动扩容。
数组的定义
go 中定义数组的方式有如下两种：
- 指定长度：
arr := [3]int{1, 2, 3}
- 不指定长度，由编译器推导出数组的长度：
arr := [...]{1, 2, 3}
上面这两种定义方式都定义了一个长度为 3 的数组。正如我们所见，长度是数组的一部分，定义数组的时候长度已经确定下来了。
切片的定义
切片的定义方式跟数组很像，只不过定义切片的时候不用指定长度：
s := []int{1, 2, 3}
在上面定义切片的代码中，我们可以看到其实跟数组唯一的区别就是少了个长度。
那其实我们可以把切片看作是一个无限长度的数组。
当然，实际上它并不是无限的，它只是在切片容纳不下新的元素的时候，会自动进行扩容，从而可以容纳更多的元素。
数组和切片的相似之处
正如我们上面看到的那样，数组和切片两者其实非常相似，在实际使用中，它们也是有些类似的。
比如，通过下标来访问元素：
arr := [3]int{1, 2, 3}
// 通过下标访问
fmt.Println(arr[1]) // 2
s := []int{1, 2, 3}
// 通过下标访问
fmt.Println(s[1]) // 2
数组的局限
我们知道了，数组的长度是固定的，这也就意味着如果我们想往数组里面增加一个元素会比较麻烦，
我们需要新建一个更大的数组，然后将旧的数据复制过去，然后将新的元素写进去，如：
// 往数组 arr 增加一个元素：4
arr := [3]int{1, 2, 3}
// 新建一个更大容量的数组
var arr1 [4]int
// 复制旧数组的数据
for i := 0; i < len(arr); i++ {
arr1[i] = arr[i]
}
// 加入新的元素：4
arr1[3] = 4
fmt.Println(arr1)
这样一来就非常的繁琐，如果我们使用切片，就可以省去这些步骤：
// 定义一个长度为 3 的数组
arr := [3]int{1, 2, 3}
// 从数组创建一个切片
s := arr[:]
// 增加一个元素
s = append(s, 4)
fmt.Println(s)
因为数组固定长度的缺点，实际使用中切片会使用得更加普遍。
重新理解 slice
在开始之前，我们来看看 slice 这个单词的意思：作为名词，slice 的意思有 片;部分;(切下的食物)薄片;，作为动词，slice 的意思有 切;把…切成(薄)片; 的意思。
从这个角度出发，我们可以把 slice 理解为从某个数组上 切下来的一部分（从这个角度看，slice 这个命名非常的形象）。我们可以看看下图：
在这个图中，A 是一个保存了数字 1~7 的 slice，B 是从 A 中 切下来的一部分，而 B 只包含了 A 中的一部分数据。
我们可以把 B 理解为 A 的一个 视图，B 中的数据是 A 中的数据的一个 引用，而不是 A 中数据的一个 拷贝
（也就是说，我们修改 B 的时候，A 中的数据也会被修改，当然会有例外，那就是 B 发生扩容的时候，再去修改 B 的话就影响不了 A 了）。
slice 的内存布局
现在假设我们有如下代码：
// 创建一个切片，长度为 3，容量为 7
var s = make([]int, 3, 7)
s[0] = 1
s[1] = 2
s[2] = 3
fmt.Println(s)
对应的内存布局如下：
说明：
slice底层其实也是数组，但是除了数组之外，还有两个字段记录切片的长度和容量，分别是len和cap。- 上图中，
slice中的array就是切片的底层数组，因为它的长度不是固定的，所以使用了指针来保存，指向了另外一片内存区域。 len表明了切片的长度，切片的长度也就是我们可以操作的下标，上面的切片长度为3，这也就意味着我们切片可以操作的下标范围是0~2。超出这个范围的下标会报错。cap表明了切片的容量，也就是切片扩容之前可以容纳的元素个数。
切片容量存在的意义
对于我们日常开发来说，slice 的容量其实大多数时候不是我们需要关注的点，而且由于容量的存在，也给开发者带来了一定的困惑。
那么容量存在的意义是什么呢？意义就在于避免内存的频繁分配带来的性能下降（容量也就是提前分配的内存大小）。
比如，假如我们有一个切片，然后我们知道需要往它里面存放 1w 个元素，
如果我们不指定容量的话，那么切片就会在它存放不下新的元素的时候进行扩容，
这样一来，可能在我们存放这 1w 个元素的时候需要进行多次扩容，
这也就意味着需要进行多次的内存分配。这样就会影响应用的性能。
我们可以通过下面的例子来简单了解一下：
// Benchmark1-20 100000000 11.68 ns/op
func Benchmark1(b *testing.B) {
var s []int
for i := 0; i < b.N; i++ {
s = append(s, 1)
}
}
// Benchmark2-20 134283985 7.482 ns/op
func Benchmark2(b *testing.B) {
var s []int = make([]int, 10, 100000000)
for i := 0; i < b.N; i++ {
s = append(s, 1)
}
}
在第一个例子中，没有给 slice 设置容量，这样它就只会在切片容纳不下新元素的时候才会进行扩容，这样就会需要进行多次扩容。
而第二个例子中，我们先给 slice 设置了一个足够大的容量，那么它就不需要进行频繁扩容了。
最终我们发现，在给切片提前设置容量的情况下，会有一定的性能提升。
切片常用操作
创建切片
我们可以从数组或切片生成新的切片：
注意：生成的切片不包含
end。
target[start:end]
说明：
target表示目标数组或者切片start对应目标对象的起始索引（包含）end对应目标对象的结束索引（不包含）
如：
s := []int{1, 2, 3}
s1 := s[1:2] // 包含下标 1，不包含下标 2
fmt.Println(s1) // [2]
arr := [3]int{1, 2, 3}
s2 := arr[1:2]
fmt.Println(s2) // [2]
在这种初始化方式中，我们可以省略 start：
arr := [3]int{1, 2, 3}
fmt.Println(arr[:2]) // [1, 2]
省略 start 的情况下，就是从 target 的第一个元素开始。
我们也可以省略 end：
arr := [3]int{1, 2, 3}
fmt.Println(arr[1:]) // [2, 3]
省略 end 的情况下，就是从 start 索引处的元素开始直到 target 的最后一个元素处。
除此之外，我们还可以指定新的切片的容量，通过如下这种方式：
target[start:end:cap]
例子：
arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
s := arr[1:4:5]
fmt.Println(s, len(s), cap(s)) // [2 3 4] 3 4
往切片中添加元素
我们前面说过了，如果我们想往数组里面增加元素，那么我们必须开辟新的内存，将旧的数组复制过去，然后才能将新的元素加入进去。
但是切片就相对简单，我们可以使用 append 这个内置函数来往切片中加入新的元素：
var a []int
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素
a = append(a, []int{1,2,3}...) // 追加一个切片
切片复制
go 有一个内置函数 copy 可以将一个切片的内容复制到另外一个切片中：
copy(dst, src []int)
第一个参数 dst 是目标切片，第二个参数 src 是源切片，调用 copy 的时候会把 src 的内容复制到 dst 中。
示例：
var a []int
var b []int = []int{1, 2, 3}
// a 的容量为 0，容纳不下任何元素
copy(a, b)
fmt.Println(a) // []
a = make([]int, 3, 3) // 给 a 分配内存
copy(a, b)
fmt.Println(a) // [1 2 3]
需要注意的是，如果 dst 的长度比 src 的长度小，那么只会截取 src 的前面一部分。
从切片删除元素
虽然我们往切片追加元素的操作挺方便的，但是要从切片删除元素就相对麻烦一些了。go 语言本身没有提供从切片删除元素的方法。
如果我们要删除切片中的元素，只有构建出一个新的切片：
对应代码：
var a = make([]int, 7, 7)
for i := 0; i < 7; i++ {
a[i] = i + 1
}
fmt.Println(a) // [1 2 3 4 5 6 7]
var b []int
b = append(b, a[:2]...) // [1 2]
b = append(b, a[5:]...) // [1 2 6 7]
fmt.Println(b) // [1 2 6 7]
在这个例子中，我们想从 a 中删除 3、4、5 这三个元素，也就是下标 2~4 的元素，
我们的做法是，新建了一个新的切片，然后将 3 前面的元素加入到这个新的切片中，
再将 5 后面的元素加入到这个新切片中。
最终得到的切片就是删除了 3、4、5 三个元素之后的切片了。
切片的容量到底是多少？
假设我们有如下代码：
var a = make([]int, 7, 7)
for i := 0; i < 7; i++ {
a[i] = i + 1
}
// [1 2 3 4 5 6 7]
fmt.Println(a)
s1 := a[:3]
// [1 2 3] 3 7
fmt.Println(s1, len(s1), cap(s1))
s2 := a[4:6]
// [5 6] 2 3
fmt.Println(s2, len(s2), cap(s2))
s1 和 s2 可以用下图表示：
s1只能访问array的前三个元素，s2只能访问5和6这两个元素。s1的容量是 7（底层数组的长度）s2的容量是 3，从5所在的索引处直到底层数组的末尾。
对于 s1 和 s2，我们都没有指定它的容量，但是我们打印发现它们都有容量，
其实在切片中，我们从切片中生成一个新的切片的时候，如果我们不指定容量，
那新切片的容量就是 s[start:end] 中的 start 直到底层数组的最后一个元素的长度。
切片可以共享底层数组
切片最需要注意的点是，当我们从一个切片中创建新的切片的时候，两者会共享同一个底层数组，
如上图的那样，s1 和 s2 都引用了同一个底层的数组不同的索引，
s1 引用了底层数组的 0~2 下标范围，s2 引用了底层数组 4~5 下标范围。
这意味着，当我们修改 s1 或 s2 的时候，原来的切片 a 也会发生改变：
var a = make([]int, 7, 7)
for i := 0; i < 7; i++ {
a[i] = i + 1
}
// [1 2 3 4 5 6 7]
fmt.Println(a)
s1 := a[:3]
// [1 2 3]
fmt.Println(s1)
s1[1] = 100
// [1 100 3 4 5 6 7]
fmt.Println(a)
// [1 100 3]
fmt.Println(s1)
在上面的例子中，s1 这个切片引用了和 a 一样的底层数组，
然后在我们修改 s1 的时候，a 也发生了改变。
切片扩容不会影响原切片
上一小节我们说了，切片可以共享底层数组。但是如果切片扩容的话，那就是一个全新的切片了。
var a = []int{1, 2, 3}
// [1 2 3] 3 3
fmt.Println(a, len(a), cap(a))
// a 容纳不下新的元素了，会进行扩容
b := append(a, 4)
// [1 2 3 4] 4 6
fmt.Println(b, len(b), cap(b))
b[1] = 100
// [1 2 3]
fmt.Println(a)
// [1 100 3 4]
fmt.Println(b)
在上面这个例子中，a 是一个长度和容量都是 3 的切片，这也就意味着，这个切片已经满了。
在这种情况下，我们再往其中追加元素的时候，就会进行扩容，生成一个新的切片。
因此，我们可以看到，我们修改了 b 的时候，并没有影响到 a。
下面的例子就不一样了：
// 长度为 2，容量为 3
var a = make([]int, 2, 3)
a[0] = 1
a[1] = 2
// [1 2] 2 3
fmt.Println(a, len(a), cap(a))
// a 还可以容纳新的元素，不用扩容
b := append(a, 4)
// [1 2 4] 3 3
fmt.Println(b, len(b), cap(b))
b[1] = 100
// [1 100]
fmt.Println(a)
// [1 100 4]
fmt.Println(b)
在后面这个例子中，我们只是简单地改了一下 a 初始化的方式，改成了只放入两个元素，但是容量还是 3，
在这种情况下，a 可以再容纳一个元素，这样在 b := append(a, 4) 的时候，创建的 b 底层的数组其实跟 a 的底层数组依然是一样的。
所以，我们需要尤其注意代码中作为切片的函数参数，如果我们希望在被调函数中修改了切片之后，在 caller 里面也能看到效果的话，最好是传递指针。
func test1(s []int) {
s = append(s, 4)
}
func test2(s *[]int) {
*s = append(*s, 4)
}
func TestSlice(t *testing.T) {
var a = []int{1, 2, 3}
// [1 2 3] 3 3
fmt.Println(a, len(a), cap(a))
test1(a)
// [1 2 3] 3 3
fmt.Println(a, len(a), cap(a))
var b = []int{1, 2, 3}
// [1 2 3] 3 3
fmt.Println(b, len(b), cap(b))
test2(&b)
// [1 2 3 4] 4 6
fmt.Println(b, len(b), cap(b))
}
在上面的例子中，test1 接收的是值参数，所以在 test1 中切片发生扩容的时候，TestSlice 里面的 a 还是没有发生改变。
而 test2 接收的是指针参数，所以在 test2 中发生切片扩容的时候，TestSlice 里面的 b 也发生了改变。
总结
- 数组跟切片的使用上有点类似，但是数组代表的是有固定长度的数据序列，而切片代表的是没有固定长度的数据序列。
- 数组的长度是类型的一部分，有两种定义数组的方式：
[2]int{1, 2}、[...]int{1, 2}。 - 数组跟切片都可以通过下标来访问其中的元素，可以访问的下标范围都是
0 ~ len(x)-1，x表示的是数组或者切片。 - 数组无法追加新的元素，切片可以追加任意数量的元素。
slice的数据结构里面包含了：array底层数组指针、len切片长度、cap切片容量。- 创建切片的时候，指定一个合适的容量可以减少内存分配的次数，从而在一定程度上提高程序性能。
- 我们可以从数组或者切片创建一个新的切片：
array[1:3]或者slice[1:3]。 - 使用
append内置函数可以往切片中添加新的元素。 - 使用
copy内置函数可以将一个切片的内容复制到另外一个切片中。 - 切片删除元素没有好的办法，只能截取被删除元素前后的数据，然后复制到一个新的切片中。
- 假设我们通过
slice[start:end]的方式从切片中创建一个新的切片，那么这个新的切片的容量是cap(slice) - start，也就是，从start到底层数组最后一个元素的长度。 - 使用切片的时候需要注意：切片之间会共享底层数组，其中一个切片修改了切片的元素的时候，也会反映到其他切片上。
- 函数调用的时候，如果被调函数内发生扩容，调用者是无法知道的。如果我们不想错过在被调函数内切片的变化，我们可以传递指针作为参数。
