每天一个知识点：Go 语言 Slice 详解

在 Go 语言中，切片(slice)可能是使用最为频繁的数据结构之一，切片类型为处理同类型数据序列提供一个方便而高效的方式。要了解 slice，首先我们要了解数组(array)。

数组（Array）

数组类型定义了长度和元素类型。数组的长度是固定的，长度也是数组类型的一部分。长度不同的两个数组是不可以相互赋值的，因为这两个数组属于不同的类型。

在 C 语言中，数组变量是指向第一个元素的指针，但是 Go 语言中并不是。Go 语言中，数组变量属于值类型(value type)，因此当一个数组变量被赋值或者传递时，实际上会复制整个数组。所以，为了避免复制数组，一般会传递指向数组的指针。

了解了 Go 语言中的数组，我们再来看切片(slice)：

切片（Slice）

切片在编译期间的生成的类型只会包含切片中的元素类型（存储在 Extra 字段中帮助程序在运行时动态获取 ），但是在运行时切片可以由如下的 reflect.SliceHeader 结构体表示:

type SliceHeader struct {
    Data uintptr // 指向数组的指针
    Len  int // 当前切片的长度
    Cap  int // 当前切片的容量，即 Data 数组的大小
}

Data 是一片连续的内存空间，这片内存空间可以用于存储切片中的全部元素，数组中的元素只是逻辑上的概念，底层存储其实都是连续的，所以我们可以将切片理解成一片连续的内存空间加上长度与容量的标识。

切片与数组的关系非常密切，切片引入了一个抽象层，提供了对数组中部分连续片段的引用，而作为数组的引用，我们可以在运行区间可以修改它的长度和范围。当切片底层的数组长度不足时就会触发扩容，切片指向的数组可能会发生变化，不过在上层看来切片是没有变化的，上层只需要与切片打交道不需要关心数组的变化。

关于容量的扩容，一般是以 2 的倍数扩大的，即2→4→8→16...，当达到 1024 时会采取新的策略，避免申请内存过大，导致浪费。扩容时会调用 runtime.growslice 函数为切片扩容，扩容是为切片分配新的内存空间并拷贝原切片中元素的过程，因此为了避免内存拷贝，如果能够知道最终切片的大小，预先设置 Cap 值能够获得最好的性能。

切片(Slice) 的使用

Go 语言在 Github 上的官方 wiki - SliceTricks 介绍了切片常见的操作技巧。非常推荐这个 网站 将这些操作以图片的形式展现出来，非常直观。

• Copy

b = make([]T, len(a))
copy(b, a)
b = append([]T(nil), a...)
b = append(a[:0:0], a...)

• Append

    a = append(a, b...)

切片有三个属性，指针(ptr)、长度(len) 和容量(cap)。append 时有两种场景：

• 当 append 之后的长度小于等于 cap，将会直接利用原底层数组剩余的空间。
• 当 append 后的长度大于 cap 时，则会分配一块更大的区域来容纳新的底层数组。
• Delete

 a = append(a[:i], a[i+1:]...)
 a = a[:i+copy(a[i:], a[i+1:])]

• 切片的底层是数组，因此删除意味着后面的元素需要逐个向前移位。每次删除的复杂度为 O(N)，因此切片不合适大量随机删除的场景，这种场景下适合使用链表。

• Delete(GC)

   copy(a[i:], a[j:])
   for k, n := len(a)-j+i, len(a); k < n; k++ {
    a[k] = nil // or the zero value of T
   }
   a = a[:len(a)-j+i]

• 删除后，将空余的位置置空，有助于垃圾回收。

• Insert

  a = append(a[:i], append([]T{x}, a[i:]...)...)
  
  

  • insert 和 append 类似。即在某个位置添加一个元素后，将该位置后面的元素再 append 回去。复杂度为 O(N)。因此，不适合大量随机插入的场景。

• Filter

  n := 0
  for _, x := range a {
   if keep(x) {
    a[n] = x
    n++
   }
  }
  a = a[:n]
  
  

  • 当原切片不会再被使用时，就地 filter 方式是比较推荐的，可以节省内存空间。

• Push(Pop)

  a = append(a, x) // 在末尾追加元素，不考虑内存拷贝的情况，复杂度为 O(1)。
  a = append([]T{x}, a...) // 在头部追加元素，时间和空间复杂度均为 O(N)，不推荐。
  x, a = a[len(a)-1], a[:len(a)-1] // 尾部删除元素，复杂度 O(1)
  x, a = a[0], a[1:] // 头部删除元素，如果使用切片方式，复杂度为 O(1)。但是需要注意的是，底层数组没有发生改变，第 0 个位置的内存仍旧没有释放。如果有大量这样的操作，头部的内存会一直被占用。
  
  

  • 在末尾追加元素，不考虑内存拷贝的情况，复杂度为 O(1)。
  • 在头部追加元素，时间和空间复杂度均为 O(N)，不推荐。
  • 尾部删除元素，复杂度 O(1)
  • 头部删除元素，如果使用切片方式，复杂度为 O(1)。但是需要注意的是，底层数组没有发生改变，第 0 个位置的内存仍旧没有释放。如果有大量这样的操作，头部的内存会一直被占用。

性能陷阱

在已有切片的基础上进行切片，不会创建新的底层数组。因为原来的底层数组没有发生变化，内存会一直占用，直到没有变量引用该数组。因此很可能出现这么一种情况，原切片由大量的元素构成，但是我们在原切片的基础上切片，虽然只使用了很小一段，但底层数组在内存中仍然占据了大量空间，得不到释放。比较推荐的做法，使用 copy 替代 re-slice。

// 不推荐
func lastNumsBySlice(origin []int) []int {
    return origin[len(origin)-2:]
}
// 推荐
func lastNumsByCopy(origin []int) []int {
    result := make([]int, 2)
    copy(result, origin[len(origin)-2:])
    return result
}

参考

Go 语言高性能编程
Go 语言设计与实现
Go Slice Tricks Cheat Sheet