在阅读Go语言圣经时，一直对数组和切片的使用场景好奇，不明白为什么推荐使用切片来代替数组。希望能通过一些梳理，能更好的理解切片和数组，找到他们合适的使用场景。
切片与数组
关于切片和数组怎么选择，我们来讨论下这个问题。
在Go中，数组是值类型，赋值和函数传参都会复制整个数组数据。
Go
func main() {
a := [2]int{100, 200}
// 赋值
var b = a
fmt.Printf("a : %p , %v\n", &a, a)
fmt.Printf("b : %p , %v\n", &b, b)
// 函数传参
f(a)
f(b)
}
func f(array [2]int) {
fmt.Printf("array : %p , %v\n", &array, array)
}输出结果：
Go
a : 0xc0000180a0 , [100 200]
b : 0xc0000180b0 , [100 200]
array : 0xc0000180f0 , [100 200]
array : 0xc000018110 , [100 200]可以看到，四个内存地址都不相同，印证了前面的说法。当数组数据量达到百万级别时，复制数组会给内存带来巨大的压力，那能否通过传递指针来解决呢?
Go
func main() {
a := [1]int{100}
f1(&a)
fmt.Printf("array : %p , %v\n", &a, a)
}
func f1(p *[1]int) {
fmt.Printf("f1 array : %p , %v\n", p, *p)
(*p)[0] += 100
}输出结果：
Go
f1 array : 0xc0000b0008 , [100]
array : 0xc0000b0008 , [200]可以看到，数组指针可以实现我们想要的效果，解决了复制数组带来的内存问题，不过函数接收的指针来自值拷贝，相对来说没有切片那么灵活。
Go
func main() {
a := [1]int{100}
f1(&a)
// 切片
b := a[:]
f2(&b)
fmt.Printf("array : %p , %v\n", &a, a)
}
func f1(p *[1]int) {
fmt.Printf("f1 array : %p , %v\n", p, *p)
(*p)[0] += 100
}
func f2(p *[]int) {
fmt.Printf("f2 array : %p , %v\n", p, *p)
(*p)[0] += 100
}
//输出结果
f1 array : 0xc000018098 , [100]
f2 array : 0xc00000c030 , [200]
array : 0xc000018098 , [300]可以看到，切片的指针和原来数组的指针是不同的。
总结
通常来说，使用数组进行参数传递会消耗较多内存，采用切片可以避免此问题。切片是引用传递，不会占用较多内存，效率更高一些。
切片的数据结构
切片在编译期是 cmd/compile/internal/types/type.go 包下的Slice类型，而它的运行时的数据结构位于 reflect.SliceHeader
Go
type SliceHeader struct {
Data uintptr // 指向数组的指针
Len int // 当前切片的长度
Cap int // 当前切片的容量，cap 总是 >= len
}
// 占用24个字节
fmt.Println(unsafe.Sizeof(reflect.SliceHeader{}))切片是对数组一个连续片段的引用，这个片段可以是整个数组，也可以是数组的一部分。切片的长度可以在运行时修改，最小为0，最大为关联数组的长度，切片是一个长度可变的动态窗口。
创建切片
使用make
Go
slice := make([]int, 4, 6)内存空间申请了6个int类型的内存大小。由于len=4，所以后面2个空间暂时无法访问到，但是容量是存在的。此时数组里每个变量都=0。
字面量
Go
slice := []int{0, 1, 2}nil切片和空切片
Go
// nil 切片
var s []int
// 空切片
s2 := make([]int, 0)
s3 := []int{}空切片和 nil 切片的区别在于，空切片指向的地址不是nil，指向的是一个内存地址，但是它没有分配任何内存空间，即底层元素包含0个元素。
Go
func main() {
var s []int
s2 := []int{}
s3 := make([]int, 0)
fmt.Println(s == nil)
fmt.Println(s2 == nil)
fmt.Println(s3 == nil)
}
// 输出结果
true
false
false简单说，nil切片指针值为nil；而空切片的指针值不为nil，原因详见bytetech.info/articles/71...
需要说明的一点是，不管是使用 nil 切片还是空切片，对其调用内置函数 append，len 和 cap 的效果都是一样的。
但使用append时要注意：
-
如果append追加的数据长度小于等于cap-len，只做一次数据拷贝。
-
如果append追加的数据长度大于cap-len，则会分配一块更大的内存，然后把原数据拷贝过来，再进行追加。
特别当我们需要构建一个切片，是从原有切片复制而来时，要注意值覆盖问题。
Go
func main() {
s1 := []int{0, 1, 2, 3} // 先定义一个现有切片
s2 := s1[0:1] // 复制现有的切片
s2 = append(s2, 100)
fmt.Print(s1)
}输出结果
Go
[0 100 2 3]原因还是切片本质上是数组的一个动态窗口，当cap够用时，不会新开辟内存空间进行复制，此时对数组的任何修改，都会对其他代理此数组的切片产生连带影响。