切片是非常常用的数据类型，属于容器类型。每一个切片背后都有一个数组作为支撑。以下代码和图片来自于g101，很好的诠释了切片的内部结构。

  1. type _slice struct {
  2.   elements unsafe.Pointer // referencing underlying elements
  3.   len      int            // length
  4.   cap      int            // capacity
  5. }

len 表示切片存储元素的数量，cap 表示切片的容量。下面这张图展示了切片的内存布局。
slice-internal2.png

一，插入切片元素

大体上分为三步，

  1. 确保切片有足够的空间来容纳新增的元素，一般利用内置函数 append，在结尾添加一个零值元素。例如，添加一个类型为T的元素：slice_data = append(slice_data, T{})
  2. 找到插入元素的位置，将后面所有元素后移一个位置。一般利用内置函数 copy 来操作切片自身。例如，插入位置i-th，copy(slice_data[i+1:], slice_data[i:])
  3. 将待插入的元素赋值到切片的插入位置。例如，slice_data[i] = T1 (类型为 T)

copy 是 golang 的内置函数，具体定义如下：

  1. // The copy built-in function copies elements from a source slice into a
  2. // destination slice. (As a special case, it also will copy bytes from a
  3. // string to a slice of bytes.) The source and destination may overlap. Copy
  4. // returns the number of elements copied, which will be the minimum of
  5. // len(src) and len(dst).
  6. func copy(dst, src []Type) int

从其说明中，可以看出能够操作切片自身，非常方便。

二，删除切片元素

有很多种删除切片元素的方法，简单常用的主要有两种。

  1. 删除后的切片，需要保持原有的顺序。那么被删除的元素后面的所有元素都需要向前移动一个位置。例如，删除 i-th 元素，

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

  2. 删除后的切片，不需要保持原有的顺序。可以将末尾的元素移到被删除的元素的位置上。例如，删除 i-th 元素，

    1. slice_data[i] = slice_data[len(slice_data - 1]
    2. slice_data = slice_data[:len(slice_data) - 1]

    为了避免原末尾的元素造成内存泄露，零值化其：

    1. slice_data[:len(slice_data)+1][len(slice_data)] = T0 (T 类型零值)

三，简单的例子实现切片插入和删除

以下是一个实例代码来展示切片的操作。在日常工作中，我们对切片的操作主要是插入一次，查询多次，这样的话，经过排序的切片，就会有较好的性能。具体代码如下：

  1. // Sample...
  2. type pair struct {
  3.         key   string
  4.         value []byte
  5. }
  7. type pairs []pair
  9. // Load retrieves the value of a key/value pair.
  10. // The given Pair must be a pointer and will
  11. // be set to the value via its key.
  12. func (p pairs) Load(one *pair) error {
  13.         i := sort.Search(len(p), func(i int) bool { return p[i].key >= one.key })
  14.         if i < len(p) && p[i].key == one.key {
  15.                 one.value = copyBytes(p[i].value)
  16.                 return nil
  17.         }
  19.         return &KeyError{Key: one.key, Err: errors.New("no such key in pairs")}
  20. }
  22. // Set adds or updates the given Pair in the pairs list.
  23. func (p *pairs) Set(one pair) {
  24.         // better make a copy to pair so not mess anything
  25.         // to pair-> value, but not if pair-> value it too big
  26.         // and won't be changed anymore.
  28.         i := sort.Search(len(*p), func(i int) bool { return (*p)[i].key >= one.key })
  29.         switch {
  30.         case i < len(*p) && (*p)[i].key == one.key:
  31.                 // pair is present at i-th element of pairs
  32.                 (*p)[i].value = copyBytes(one.value)
  34.         case i < len(*p):
  35.                 // insert pair before i-th element of pairs
  36.                 // total 3 steps:
  37.                 // 1. append zero value of pair
  38.                 *p = append(*p, pair{})
  40.                 // 2. existing elements of pairs must be shifted
  41.                 copy((*p)[i+1:], (*p)[i:])
  43.                 // 3. set the pair at the i-th element
  44.                 (*p)[i].key = one.key
  45.                 (*p)[i].value = copyBytes(one.value)
  47.         default:
  48.                 // pair should be placed at the end of pairs
  49.                 *p = append(*p, pair{key: one.key, value: copyBytes(one.value)})
  50.         }
  51. }
  53. // Delete deletes the value of a key/value pair.
  54. // The given Pair must be a pointer
  55. func (p *pairs) Delete(one *pair) {
  56.         i := sort.Search(len(*p), func(i int) bool { return (*p)[i].key >= one.key })
  57.         if i < len(*p) && (*p)[i].key == one.key {
  58.                 *p = append((*p)[:i], (*p)[i+1:]...)
  59.         }
  60. }
  62. func copyBytes(src []byte) []byte {
  63.         if src == nil {
  64.                 return nil
  65.         }
  67.         dst := make([]byte, len(src))
  68.         copy(dst, src)
  70.         return dst
  71. }
  73. type KeyError struct {
  74.         Key string
  75.         Err error
  76. }
  78. func (e *KeyError) Error() string {
  79.         return fmt.Sprintf("Pair-> key %q: %v", e.Key, e.Err)
  80. }

简单的 main 函数如下：

  1. func SliceOp() error {
  2.         cities := pairs([]pair{
  3.                 pair{
  4.                         "BJ",
  5.                         []byte("Beijing"),
  6.                 },
  8.                 pair{
  9.                         "SH",
  10.                         []byte("Shanghai"),
  11.                 },
  12.         })
  14.         // set a new one
  15.         dalian := pair{
  16.                 "DL",
  17.                 []byte("Dalian"),
  18.         }
  20.         cities.Set(dalian)
  22.         fmt.Println("Pair List:")
  23.         for _, c := range cities {
  24.                 fmt.Println("  ", c.key, " - ", string(c.value))
  25.         }
  27.         // load one
  28.         r := pair{key: "BJ"}
  29.         err := cities.Load(&r)
  30.         if err != nil {
  31.                 return err
  32.         }
  34.         fmt.Println("\nRetrieve:", "\n  Key:", r.key, "\n  Values:", string(r.value))
  36.         // delete one
  37.         cities.Delete(&r)
  39.         fmt.Println("\nAfter deleting, Pair List:")
  40.         for _, c := range cities {
  41.                 fmt.Println("  ", c.key, " - ", string(c.value))
  42.         }
  44.         return nil
  45. }

输出结果如下：

  1. Pair List:
  2.    BJ  -  Beijing
  3.    DL  -  Dalian
  4.    SH  -  Shanghai
  6. Retrieve:
  7.   Key: BJ
  8.   Values: Beijing
  10. After deleting, Pair List:
  11.    DL  -  Dalian
  12.    SH  -  Shanghai

参考链接：