【Golang】怎样优雅的清空切片

DDGarfield

发布于 2022-06-23 19:26:57

1.6K0

发布于 2022-06-23 19:26:57

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

场景是这样的：需要批量从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仍有数据，继续查询剩下的。

1.方法一

像上面的代码一样：

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

2.方法二

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

2.1 是一样吗？

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

我们增加如下代码：

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

再看下上面的方法

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

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

要检查切片是否为空，请始终使用len(s) == 0来判断，而不应该使用s == nil来判断。
- 正如上面的sliceIntA一样，虽然是空切片，但是却不是零值。
- 一个nil值的切片并没有底层数组，但是一个nil值的切片的长度和容量都是0。但是我们却不能说一个长度和容量都是0的切片一定是nil；
- 通过nil清空切片后，切片就没有指向的底层数组，如果没有其他引用这个底层数组，没猜错的话，恐怕只能依靠GC回收了。

2.2 再比较不同

为了更直观的看出内存地址的不同，我们基于数组通过切片表达式得到切片，且从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 0xc00000c1e02.sliceIntA 0xc00000c1e0[1 2 3 4 5 6]1.array  0xc00000c1e0# 清空方法一2.sliceIntA 0x108de00# 清空方法二2.sliceIntA 0x01.array  0xc00000c1e0# append2.sliceIntA 0xc0000120d0

可以看出：

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

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

3.更优雅的方法

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

在需要清空继续append操作的情况下，均会导致底层更换数组，开辟新的空间，原有底层数组恐怕依靠GC回收了；
切片清空后，除了长度归0，容量也归0了，这其实并不利于我们后续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 0xc00000c1e0sliceIntA 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 0xc00000c1e0sliceIntA 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 0xc00000c1e0sliceIntA 0xc00000c1e0[999 888][999 888 3 4 5 6 7 8 9 10]len of sliceIntA:2,cap of sliceIntA:10array 0xc00000c1e0sliceIntA 0xc00000c1e0[777 888][777 888 3 4 5 6 7 8 9 10]len of sliceIntA:2,cap of sliceIntA:10

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

4.结论

算下来就有3种清空切片的方法，但是他们的本质各不相同，对性能没啥极致的要求，都可使用，如果还有其他特别的需求，一定要留心底层数组是否更换，请小心使用。当然，如果仅仅是清空切片，后续继续append操作，博主更推荐切片表达式的方法[0:0]。

------------------- End -------------------

本文参与腾讯云自媒体分享计划，分享自微信公众号。

原始发表：2021-07-21，如有侵权请联系 cloudcommunity@tencent.com 删除

jquery

编程算法

本文分享自加菲的博客微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

jquery

编程算法

登录后参与评论

0 条评论

热度