golang slice && array

array 和slice都是数组，前者固定大小，值类型;后者可以动态变更，引用类型。
再次强调一遍，array在golang中是值类型，而不是c中的指针，在函数传参时，会重新复制整个数组。因而大多数都是使用slice.slice 底层是一个array。两者数据结构如下:

array数据结构

slice数据结构

---

初始化

• array
  var b [2]int // 零值
  b := [2]int{1,2}
  b := [...]int{1,2} // 自动计算长度

• slice
  var s []int // 空指针,相当于 ([]int)(nil)
  s := []int{1,2} 或者通过make
  s := make([]int,2) // 长度和容量都是2
  s := make([]int, 2, 4) //长度为2，容量为4
  s := b[:] // 从其他array切分，共享底层数据,即修改其中一个，另一个也会跟着改变

package danmu

import (
    "fmt"
    "testing"
)

func TestInterfaceKey(t *testing.T) {
    var a [2]int
    fmt.Println("array init", a[0])
    var s []int
    // s[0] 会直接报空指针错误
    s = a[:]
    fmt.Println("create slice from a ", a, " \t", s)

    a[0] = 1 // 修改array
    s[1] = 2 // 修改slice
    fmt.Println("after changed both value", a, " \t ", s)
}

bash-3.2$ go test  -v -run TestInterfaceKey
=== RUN   TestInterfaceKey
array init 0
create slice from a  [0 0]       [0 0]
after changed both value [1 2]            [1 2]

---

slice 操作

先说说make函数。

func make([]T, len, cap) []T

len:数据大小;cap:容量大小，slice实际能访问的大小由len决定，有段时间觉得cap只是个占坑的。下面写append时会说到用处。

• 切分操作
  切分会生成一个共享源数据的slice。

  s表示数据源，可以是array也可以是slice; idx表示索引

  • 整个拷贝 : s1 := s[:]
  • 从某个开始到末尾: s1 := s[idx:]
  • 截到某个为止: s1 := s[:idx]
  • 从某个开始截取到某个为止: s1 := s[idx1:idx2]

• 追加操作
  func append(slice [][Type], elems ...[Type],将数据添加到尾端，当容量不足时，会重新生成一个底层array，并把之前的数据复制过去。上面说的cap，就是这个作用，事先分配合适的容量，可以提升性能。
  用法:

slice = append(slice, elem1, elem2)
slice = append(slice, anotherSlice...)

package danmu

import (
    "fmt"
    "testing"
)

func TestInterfaceKey(t *testing.T) {
    s := make([]int, 1, 3)

    fmt.Printf("%p %v \n", s, s[0])
    // fmt.Println(s[1]) 越界
    s = append(s, 2)
    fmt.Printf("%p %v \n", s, s[1]) // 注意这里的指针和上面的指针一样，因为没有超出他的容量

    s = append(s, 3, 4)
    fmt.Printf("%p  \n", s) // 这里指针变化。前面追加的时候，已经超过了容量，会重新生成一个新的slice
    s1 := s[1:]
    fmt.Println(s1)
    s1[0] = 1123
    fmt.Println("after changed :: ", s1, " \t s0 : ", s)
}

• 混合使用

  • 任意位置插入任意数据

      s1 := make([]T, len(s[:idx])
      copy(s1, s[:idx])
      s = append(append(s1, value ),s[idx:]...))    
      如果value是一个slice, append(s1, value )替换为append(s1, value... )
    

    思考下为什么不直接用append([s[:idx],value)?

  • 删除数据: s = append(s[:idx], [idx+N:])

为什么不直接用append(s[:idx],value)

切分生成的slice会共享源数据，再调用append时，如果这时容量足够，就不会重新生成一个底层的array,相当于修改之前的数据，那么再次调用s[idx:]时，相当于在修改过的数据重新截取数据，会出现数据污染。

package danmu

import (
    "fmt"
    "testing"
)

func TestInterfaceKey(t *testing.T) {

    s := make([]int, 3, 5) //下面追加another是不会超出容量
    s[0] = 1
    s[1] = 2
    s[2] = 3

    another := []int{200, 201}

    s2 := append(append(s[:1], another...), s[1:]...)
    fmt.Println(s2)

}
我们期望的结果:
s2 : [1,200,201,2,3]

实际运行结果:
bash-3.2$ go test  -v -run TestInterfaceKey
=== RUN   TestInterfaceKey
[1 200 201 200 201]