在阅读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够用时,不会新开辟内存空间进行复制,此时对数组的任何修改,都会对其他代理此数组的切片产生连带影响。