这是个有意思的问题，在此之前，博主从来没有考虑过这个问题，直到最近，终究还是与 清空切片 相遇了。
场景是这样的：需要批量从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]