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

场景是这样的：需要批量从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) // 输出 0xb3fe00
fmt.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 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后，就指向了新的底层数组，原有的底层数组不变；

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

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 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】来几道题以加强切片知识

4. 结论

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