这是个有意思的问题,在此之前,博主从来没有考虑过这个问题,直到最近,终究还是与 清空切片 相遇了。

场景是这样的:需要批量从influxdb中查询数据,这个批量查询的查询条件是通过遍历一个结构体切片的字段,不断append,为了避免一次查询量过大,影响查询效率。代码上做了如下处理:

var queryIDs []int64
for _,v:= range vList{
    queryIDs=append(queryIDs,v.ID)
    if len(queryIDs)>50{
        //omit query code
        queryIDs=[]int64{}
    }
}

if len(queryIDs) > 0 {
     //omit query code
}

遍历过程中,当queryIDs的长度超过50,马上启动查询,查询完成后,切片清空,遍历结束后,queryIDs仍有数据,继续查询剩下的。

方法一

像上面的代码一样:

func main() {
    sliceIntA := make([]int, 0, 50)
    sliceIntA = append(sliceIntA, 1, 2, 3)
    sliceIntA = []int{}
}

这是一种方法,但是我们想要知道这时切片发生了什么变化?

func main() {
    sliceTestB := make([]int, 0, 50)
    fmt.Printf("len of sliceIntA:%d,cap of sliceIntA:%d\n", len(sliceIntA), cap(sliceIntA))
    sliceTestB = append(sliceTestB, 1, 2, 3)
    fmt.Printf("len of sliceIntA:%d,cap of sliceIntA:%d\n", len(sliceIntA), cap(sliceIntA))
    sliceTestB = []int{}
    fmt.Printf("len of sliceIntA:%d,cap of sliceIntA:%d\n", len(sliceIntA), cap(sliceIntA))
}
len of sliceIntA:0,cap of sliceIntA:50
len of sliceIntA:3,cap of sliceIntA:50
len of sliceIntA:0,cap of sliceIntA:0

可以看出通过此种方法清空的切片,长度len为0,容量cap也为0

方法二

Go语言中,类型的初始值被称为零值,常见的布尔类型的零值为 false,数值类型的零值为 0,字符串类型的零值为空字符串 “” ,而pointer、slice、map、channel、func和interface的零值则是 nil 。那么我们是否可以用 nil 来清空切片呢?

func main() {
    array := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    sliceIntB := array[2:6]
    sliceIntB = nil
}
func main() {
    array := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    sliceIntB := array[2:6]
    sliceIntB = nil
    fmt.Printf("len of sliceIntB:%d,cap of sliceIntB:%d\n", len(sliceIntB), cap(sliceIntB))
}
len of sliceIntB:0,cap of sliceIntB:0

是一样吗?

从输出结果来看,好似与上面的方法的效果是一样的。事实是这样的么?

我们增加如下代码:

fmt.Printf("%p\n", sliceIntB) // 输出 0x0
fmt.Println(sliceIntB==nil) //true

再看下上面的方法

fmt.Printf("%p\n", sliceIntA) // 输出 0xb3fe00
fmt.Println(sliceIntA==nil) //false

看吧,从切片的长度和容量上来看,以上两种都算是清空了切片,长度和容量都归0。在博主学习go语言之初,就被前辈告诉:

len(s) == 0s == nilnilGC

再比较不同

为了更直观的看出内存地址的不同,我们基于数组通过切片表达式得到切片,且从0开始切,这样能得到一样的地址。

func main() {
	array := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	sliceIntA := array[0:6]
	fmt.Printf("1.array %p\n", &array)
	fmt.Printf("2.sliceIntA %p\n", sliceIntA)
	fmt.Println(sliceIntA)
	sliceIntA = []int{}
	fmt.Printf("1.array  %p\n", &array)
	fmt.Printf("2.sliceIntA %p\n", sliceIntA)
	sliceIntA = nil
	fmt.Printf("2.sliceIntA %p\n", sliceIntA)
	fmt.Printf("1.array  %p\n", &array)
	sliceIntA = append(sliceIntA, 1)
	fmt.Printf("2.sliceIntA %p\n", sliceIntA)
}
1.array 0xc00000c1e0
2.sliceIntA 0xc00000c1e0
[1 2 3 4 5 6]
1.array  0xc00000c1e0

# 清空方法一
2.sliceIntA 0x108de00

# 清空方法二
2.sliceIntA 0x0
1.array  0xc00000c1e0

# append
2.sliceIntA 0xc0000120d0

可以看出:

  • 使用方法一清空后,切片指向的底层数组更改了,原有的底层数组不变,因此此时再操作切片,不会影响原有底层数组;
  • 使用nil清空后,切片就没有底层数组了,append后,就指向了新的底层数组,原有的底层数组不变;

由此可以得到结论:以上清空方式,均会导致底层更换数组。

更优雅的方法

看起来上面好像已经满足了我们清空切片的需求,但是会有如下问题:

append

以上两个问题都会有一点性能问题,大多数情况,我们可以忽略,但是,我们不禁还是要问:还有更优雅的清空切片方法吗?

func main() {
	array := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	sliceIntA := array[0:6]
	fmt.Printf("array %p\n", &array)
	fmt.Printf("sliceIntA %p\n", sliceIntA)
	fmt.Println(array)
	fmt.Println(sliceIntA)
	fmt.Printf("len of sliceIntA:%d,cap of sliceIntA:%d\n", len(sliceIntA), cap(sliceIntA))
	sliceIntA = sliceIntA[0:0]
	fmt.Printf("array %p\n", &array)
	fmt.Printf("sliceIntA %p\n", sliceIntA)
	fmt.Println(sliceIntA)
	fmt.Println(array)
	fmt.Printf("len of sliceIntA:%d,cap of sliceIntA:%d\n", len(sliceIntA), cap(sliceIntA))
}
array 0xc00000c1e0
sliceIntA 0xc00000c1e0
[1 2 3 4 5 6 7 8 9 10]
[1 2 3 4 5 6]
len of sliceIntA:6,cap of sliceIntA:10
#清空后
array 0xc00000c1e0
sliceIntA 0xc00000c1e0
[]
[1 2 3 4 5 6 7 8 9 10]
len of sliceIntA:0,cap of sliceIntA:10

通过输出,我们很容易得到如下结论:

  • 通过切片表达式清空切片,仅长度归0,而容量维持不变
    • 解决了可能扩容的问题
  • 清空后,切片指向的底层数组也不变
    • 解决了更换底层数组,开辟新空间,以及可能的垃圾回收问题

注意:切片指向的底层数组不变,也就导致了无论是通过切片操作还是数组操作,都会影响彼此。

sliceIntA = append(sliceIntA, 999) //切片清空后append值
sliceIntA = append(sliceIntA, 888) //切片清空后append值
fmt.Printf("array %p\n", &array)
fmt.Printf("sliceIntA %p\n", sliceIntA)
fmt.Println(sliceIntA) //[999 888]
fmt.Println(array) //[999 888 3 4 5 6 7 8 9 10]
fmt.Printf("len of sliceIntA:%d,cap of sliceIntA:%d\n", len(sliceIntA), cap(sliceIntA))
array[0]=777  //通过数组索引修改值
fmt.Printf("array %p\n", &array)
fmt.Printf("sliceIntA %p\n", sliceIntA)
fmt.Println(sliceIntA)  // [777 888]
fmt.Println(array) //[777 888 3 4 5 6 7 8 9 10]
fmt.Printf("len of sliceIntA:%d,cap of sliceIntA:%d\n", len(sliceIntA), cap(sliceIntA))
array 0xc00000c1e0
sliceIntA 0xc00000c1e0
[999 888]
[999 888 3 4 5 6 7 8 9 10]
len of sliceIntA:2,cap of sliceIntA:10
array 0xc00000c1e0
sliceIntA 0xc00000c1e0
[777 888]
[777 888 3 4 5 6 7 8 9 10]
len of sliceIntA:2,cap of sliceIntA:10

看,此时修改切片会影响数组,修改数组会影响切片,直到切片长度即将超越容量,底层数组更换,它俩才会脱钩,这个结论,请移步博主的另一篇文章【Golang】来几道题以加强切片知识

结论

append[0:0]

转载自(好的文章,值得转载)