go slice 数组和切片使用区别示例解析

正文

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 到底层数组最后一个元素的长度。
• 使用切片的时候需要注意：切片之间会共享底层数组，其中一个切片修改了切片的元素的时候，也会反映到其他切片上。
• 函数调用的时候，如果被调函数内发生扩容，调用者是无法知道的。如果我们不想错过在被调函数内切片的变化，我们可以传递指针作为参数。