切片的定义
数组[3]int，切片[]int
切片可理解为长度可变的数组
创建切片
- 基于数组的切片
// 先定义一个数组
months := [...]string{"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}
// 基于数组创建切片
q2 := months[3:6] // 第二季度
summer := months[5:8] // 夏季
fmt.Println(q2)
fmt.Println(summer)
切片底层引用了一个数组，由三个部分构成：指针，长度，容量
切片.jpg
- 基于切片的切片
firsthalf := months[:6]
q1 := firsthalf[:3] // 基于 firsthalf 的前 3 个元素构建新切片
q1 := firsthalf[:9]
因为firsthalf 的容量是 12，只要选择的范围不超过 firsthalf 的容量，
那么这个创建操作就是合法的，
所以虽然是基于切片创建切片，但本质上还是基于数组。
- 直接创建的切片
mySlice1 := make([]int, 5) // 长度和容量都为5
mySlice2 := make([]int, 5, 10) // 长度为5 容量为10
mySlice3 := []int{1, 2, 3, 4, 5} // 长度和容量都为5
Go底层依旧会创建一个匿名数组，最终切片都是基于数组创建的
切片==操作数组的指针
切片的遍历
A:
for i := 0; i < len(summer); i++ {
fmt.Println("summer[", i, "] =", summer[i])
}
B:
for i, v := range summer {
fmt.Println("summer[", i, "] =", v)
}
动态增加元素
切片的容量初始值：
基于数组或切片：当前切片起始索引---底层数组结尾索引
基于内置函数make：未指定容量参数时，容量==长度
- 长度：
len() - 容量：
cap() - 追加新元素或新切片：
append()
var oldSlice = make([]int, 5, 10)
fmt.Println("len(oldSlice):", len(oldSlice))
fmt.Println("cap(oldSlice):", cap(oldSlice))
newSlice := append(oldSlice, 1, 2, 3) // [0 0 0 0 0 1 2 3] 长度为8 容量为10
appendSlice := []int{1, 2, 3, 4, 5}
newSlice := append(oldSlice, appendSlice...) // 注意末尾的 ... 不能省略
自动扩容
如果追加后元素个数超出oldSlice的默认容量（10），底层会自动扩容
但是：
append()函数不会改变原来的切片，而是生成一个容量更大的切片，然后将原有元素与新添加元素一并拷贝到新切片中
复制内容
内置copy()函数：
即：按照其中较小的切片元素个数进行复制
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
// 复制 slice1 到 slice 2
copy(slice2, slice1) // 只会复制 slice1 的前3个元素到 slice2 中
// slice2 结果: [1, 2, 3]
// 复制 slice2 到 slice 1
copy(slice1, slice2) // 只会复制 slice2 的 3 个元素到 slice1 的前 3 个位置
// slice1 结果：[5, 4, 3, 4, 5]
动态删除元素
- 通过
再切片实现伪删除“我可以假装看不见~” - 通过
append()和copy()实现
slice3 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
slice4 := append(slice3[:0], slice3[3:]...) // 删除开头三个元素
slice5 := append(slice3[:1], slice3[4:]...) // 删除中间三个元素
slice6 := append(slice3[:0], slice3[:7]...) // 删除最后三个元素
slice7 := slice3[:copy(slice3, slice3[3:])] // 删除开头前三个元素
与动态增加元素一样，原切片并没有变动，而是创建出新的内存空间
数据共享问题
切片底层由数组实现，对应结构体：
type slice struct {
array unsafe.Pointer //指向存放数据的数组指针
len int //长度有多大
cap int //容量有多大
}
切片为引用类型：
slice1 := []int{1, 2, 3, 4, 5}
slice2 := slice1[1:3]
slice2[1] = 6
fmt.Println("slice1:", slice1) //slice1: [1 2 6 4 5]
fmt.Println("slice2:", slice2) //slice2: [2 6]
slice2 是基于 slice1创建的，它们的数组指针指向了同一个数组，因此，修改 slice2元素会同步到slice1，因为修改的是同一份内存数据，这就是数据共享问题
解决方案
slice1 := make([]int, 4)
slice2 := slice1[1:3]
slice1 = append(slice1, 0) //由于超出slice1容量（4），进行扩容，重新分配内存
slice1[1] = 2
slice2[1] = 6
fmt.Println("slice1:", slice1) // slice1: [0 2 0 0 0]
fmt.Println("slice2:", slice2) // slice2: [0 6]
虽然slice2 是基于slice1创建的，但是修改 slice2不会再同步到 slice1，因为 append() 函数会重新分配新的内存，然后将结果赋值给 slice1，这样一来，slice2会和老的 slice1 共享同一个底层数组内存，不再和新的 slice1 共享内存，也就不存在数据共享问题了。
也就是从浅拷贝变为了深拷贝
注意：上面的append()一定要重新分配内存空间，如果没有进行重新分配，依旧存在数据共享问题：
slice1 := make([]int, 4, 5)
slice2 := slice1[1:3]
slice1 = append(slice1, 0) // 没有超出slice1的容量（5），不会重新分配内存空间
slice1[1] = 2
slice2[1] = 6
fmt.Println("slice1:", slice1) // slice1: [0 2 6 0 0]
fmt.Println("slice2:", slice2) // slice2: [2 6]