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