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

最新推荐文章于 2023-09-04 02:42:31 发布

暮的秋歌

最新推荐文章于 2023-09-04 02:42:31 发布

阅读量2.3k

点赞数

分类专栏： go 文章标签： golang 开发语言后端

原文链接：http://www.randyfield.cn/post/2021-07-20-go-how-to-clear-slice/

版权

go 专栏收录该内容

37 篇文章 1 订阅

订阅专栏

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

场景是这样的：需要批量从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) == 0来判断，而不应该使用s == nil来判断。
- 正如上面的sliceIntA一样，虽然是空切片，但是却不是零值。
- 一个nil值的切片并没有底层数组，但是一个nil值的切片的长度和容量都是0。但是我们却不能说一个长度和容量都是0的切片一定是nil；
- 通过nil清空切片后，切片就没有指向的底层数组，如果没有其他引用这个底层数组，没猜错的话，恐怕只能依靠GC回收了。

再比较不同

为了更直观的看出内存地址的不同，我们基于数组通过切片表达式得到切片，且从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操作的情况下，均会导致底层更换数组，开辟新的空间，原有底层数组恐怕依靠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 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】来几道题以加强切片知识

结论

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

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

原文作者：Garfield
原文链接：http://www.randyfield.cn/post/2021-07-20-go-how-to-clear-slice/
版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议进行许可，非商业转载请注明出处（作者，原文链接），商业转载请联系作者获得授权。

暮的秋歌

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【Golang】怎样优雅的清空切片

这是个有意思的问题，在此之前，博主从来没有考虑过这个问题，直到最近，终究还是与相遇了。场景是这样的：需要批量从中查询数据，这个批量查询的查询条件是通过遍历一个结构体切片的字段，不断append，为了避免一次查询量过大，影响查询效率。过程中，当queryIDs的长度超过50，马上启动查询，查询完成后，，遍历结束后，queryIDs仍有数据，继续查询剩下的。
复制链接

扫一扫