前言
我总想着搞清楚，什么样的技术文章才算是好的文章呢？因为写一篇今后自己还愿意阅读的文章并不容易，暂时只能以此为目标努力。
最近开始用Go刷一些题，遇到了一些切片相关的细节问题，这里做一些总结。切片的设计想法是由动态数组概念而来，为了开发者可以更加方便的使一个数据结构可以自动增加和减少。但是切片本身并不是动态数据或者数组指针。
切片的结构
type slice struct {
array unsafe.Pointer // 一个指向底层数组的指针（切片中元素是存在这个指向的数组中）
len int // 切片的长度：包含的元素个数
cap int // 切片的容量，len <= cap，如果len == cap，则添加元素会触发切片的扩容
}长度为3，容量为5的int切片的图示如下，此时切片数组中可访问的部分只有下标0，1，2，超过部分不能访问。
声明和初始化
nil切片
声明nil切片，声明之后就会初始化（默认会用nil初始化），此时slice == nil成立，用于描述一个不存在的切片。
var slice []int // 此时 slice == nil 成立
空切片
声明并初始化空切片，表示一个空的集合，空切片指向地址不是nil。
slice := make([]int, 0) // 此时 slice == nil 不成立
slice := []int{}
无论是nil切片还是空切片在调用内置函数append、len和cap的效果都是一样的。
含有元素的切片
此时切片非空。
slice := []int{1, 2, 3, 4, 5} // 声明并初始化一个切片，len和cap都是5
slice := make([]int, 4) // 声明并初始化一个切片，第二个参数表示切片的长度len和容量cap都为4
slice := make([]int, 4, 6) // 声明并初始化一个切片，第二个参数表示len，第三个表示cap
-----------------------------------------------------------
array := [4]int{1, 2, 3, 4}
slice := array[1:2] // 对于array[i:j]来说，新切片的len=j-i，且cap=k-i（这里k是原数组的大小）
测试上面第四种初始化切片的方法：
func main() {
array := [...]int{1, 2, 3, 4}
slice := array[1:2]
fmt.Printf("%p %d %d %v\n", &slice, len(slice), cap(slice), slice)
}
/*
输出：
0xc00000c030 1 3 [2]
*/拷贝
使用 := 拷贝
注意：下面代码中newSlice切片是通过slice切片声明并初始化的，虽然两个切片打印的地址不同，但是切片的地址指针指向的数组是同一个。修改slice[0] = 100之后，newSlice[0]也变成100。这种规则适用于将切片作为参数传递给函数，在函数的内部使用的是传入切片的值拷贝（创建一块新的内存存放切片，但切片的地址指针指向的是同一个数组）
func main() {
array := [...]int{1, 2, 3, 4}
slice := array[1:2]
newSlice := slice // 拷贝，newSlice由一块新的内存存放slice切片信息
/*
上面这种初始化newSlice的写法等价于：
var newSlice []int
newSlice = slice
*/
fmt.Printf("%p %d %d %v\n", &slice, len(slice), cap(slice), slice)
fmt.Printf("%p %d %d %v\n", &newSlice, len(newSlice), cap(newSlice), newSlice)
slice[0] = 100
fmt.Printf("%p %d %d %v\n", &slice, len(slice), cap(slice), slice)
fmt.Printf("%p %d %d %v\n", &newSlice, len(newSlice), cap(newSlice), newSlice)
}
/*
输出：
0xc00000c030 1 3 [2]
0xc00000c048 1 3 [2]
0xc00000c030 1 3 [100]
0xc00000c048 1 3 [100]
*/使用copy函数拷贝
copy函数的两个参数是两个切片（将第二个切片的值覆盖到第一个切片），二者地址指针指向两个不同的数组。
func main() {
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
fmt.Printf("%d %d %p %v\n", len(slice1), cap(slice1), &slice1, slice1)
fmt.Printf("%d %d %p %v\n", len(slice2), cap(slice2), &slice2, slice2)
//copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置
fmt.Printf("%d %d %p %v\n", len(slice1), cap(slice1), &slice1, slice1)
//fmt.Printf("%d %d %p %v\n", len(slice2), cap(slice2), &slice2, slice2)
slice2[0] = 200
slice1[0] = 100
fmt.Printf("%d %d %p %v\n", len(slice1), cap(slice1), &slice1, slice1)
fmt.Printf("%d %d %p %v\n", len(slice2), cap(slice2), &slice2, slice2)
}
/*
输出：
5 5 0xc00000c018 [1 2 3 4 5]
3 3 0xc00000c030 [5 4 3]
5 5 0xc00000c018 [5 4 3 4 5]
5 5 0xc00000c018 [100 4 3 4 5] copy函数的两个切片的地址指针分别指向两个不同的数组（修改值互不影响）
3 3 0xc00000c030 [200 4 3]
*/扩容
扩容使用append方法。
len == cap 时添加元素
func main() {
slice := []int{1, 2, 3} // 此时slice的len == cap == 3，append元素会触发扩容，扩容后切片地址指向新数组（具体扩容策略这里暂时不多深入）
fmt.Printf("%p %d %d %v\n", &slice, len(slice), cap(slice), slice)
newSlice := append(slice, 1)
fmt.Printf("%p %d %d %v\n", &newSlice, len(newSlice), cap(newSlice), newSlice)
slice[0] = 100
fmt.Printf("%p %d %d %v\n", &slice, len(slice), cap(slice), slice)
fmt.Printf("%p %d %d %v\n", &newSlice, len(newSlice), cap(newSlice), newSlice)
}
/*
输出：
0xc00000c030 3 3 [1 2 3]
0xc00000c060 4 6 [1 2 3 1] // append一个元素之后，切片中指针指向一个扩容后新的数组（地址指针变化，这里打印出的是切片地址，无论是否扩容newSlice和slice内存地址必然是不同的，和二者拥有的地址指针不要搞混）
0xc00000c030 3 3 [100 2 3] // 修改slice[0]的元素为100
0xc00000c060 4 6 [1 2 3 1] // 但是newSlice[0]中的元素没有变化（这里才可以证明两个切片的地址指针指向两个不同的数组）
*/len < cap 时添加元素
此时调用append方法添加一个元素1并不会创建新的数组，但是1会去覆盖掉array[2]。
func main() {
array := [4]int{1, 2, 3, 4}
slice := array[0:2]
fmt.Printf("%p %d %d %v\n", &slice, len(slice), cap(slice), slice)
newSlice := append(slice, 1)
fmt.Printf("%p %d %d %v\n", &newSlice, len(newSlice), cap(newSlice), newSlice)
slice[0] = 100
fmt.Printf("%p %d %d %v\n", &slice, len(slice), cap(slice), slice)
fmt.Printf("%p %d %d %v\n", &newSlice, len(newSlice), cap(newSlice), newSlice)
fmt.Println("array = ", array)
}
/*
输出：
0xc00000c030 2 4 [1 2] // 这里看到从数组中初始化的slice的len==2且cap==4
0xc00000c060 3 4 [1 2 1] // append之后，添加一个元素，len变为3（且append元素会覆盖底层数组，这里1覆盖了之前的3）
0xc00000c030 2 4 [100 2] // 注意，这里slice打印出来的len还是2，slice的len和cap与newSlice的len和cap是隔离的，尽管它们地址指针指向的是同一个数组，这里修改了slice[0]=100
0xc00000c060 3 4 [100 2 1] // newSlice[0]也被修改为100
array = [100 2 1 4] // 证明指向的array数组也被修改了
*/结束
快过年了，祝大家新年快乐，春招offer拿不停。
