Slice
1.切片定义
切片是指向底层数组 指针、能访问的元素个数（切片长度）和 允许增长的元素个数（切片容量）组成
2.切片底层实现
数据结构如下
type slice struct {
array unsafe.Pointer
len int
cap int
}
注意
其中cap总是大于len的，如果初始化的时候小于会报错
3.切片与数组
功能
1.数组定义之后是固定的，slice可以动态操作（设计理念来自于动态数组），可以做一些截取、append等操作
值 or 引用
1.数组传的是值，复制给另外一个数组的时候会复制，从而消耗很多内存（如果数组很大）
2.切片传的是引用，所以不需要额外的内存，比数组更有效
3.切片底层数组可能会在堆上分配内存，而且小的数组在栈上拷贝的消耗也未必比make大
4.但是并非所有的时候，
4.切片初始化
var slice []int //nil 切片 需要进行初始化之后才能用
使用make创建
slice := make([]int, 3) //len 3, cap 3
slice := make([]int, 3, 5) //len 3， cap 5
使用字面量创建 (这种方法与数组类似)
#创建切片
slice := []int{1,2,3} //len 3, cap 3
#创建数组
slice := [10]int{1,2,3} //大小为10的数组
#只初始化某个索引值
s := []int{4:1} //len 5, cap 5 ,value [0 0 0 0 1]
基于已有数组或者切片创建
s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
#两个索引截取
s1 := s[:] //[0 1 2 3 4 5 6 7 8 9]
s2 := s[2:] //[2 3 4 5 6 7 8 9]
s3 := s[:4] //[0 1 2 3]
s4 := s[2:4] //[2, 3]
#三个索引截取,第三个参数限定slice的容量
s4 := s[2:4:8]
#原切片和新切片同一底层数组，改变新切片值的时候，原切片也会变
s := []int{1, 2, 3 ,4 ,5}
s1 = s[1:4]
fmt.Println("before s:", s) //[1 2 3 4 5]
fmt.Println("before s1:", s1) //[2 3 4]
s1[1] = 10
fmt.Println("after,s:",s) //[1 10 3 4 5]
fmt.Println("after, s1:", s1) //[10 3 4 ]
注意：
1.大小为cap的切片截取之后的slice的len和cap如何算
在执行[i, j]操作之后， 获得的新切片长度：j -i , 容量 cap-i
举例： s[2:4]， 长度：4-2=2, 容量： 10-2=8
2.可以用两个索引截取，也可以用三个索引截取
第三个索引参数表示限定切片容量，该容量不能大于原来切片的容量
- 原切片和新切片是基于同一个底层数组的
只是指针指向不同的位置，容量和长度可能不同
所以当心的切片值修改的时候，原切片的值也会跟着修改
4.如果用append()函数进行追加，可能改变原来底层数组的值，也可能新建一个底层数组
5.空切片和nil切片
空切片和nil切片的区别，如下图
6.切片append
考点1 扩容
情况1：在容量够用的情况下追加，修改原来切片的值
func main() {
array := [4]int{10, 20, 30, 40}
slice := array[0:2]
newSlice := append(slice, 50)
fmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
fmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
newSlice[1] += 10
fmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
fmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
fmt.Printf("After array = %v\n", array)
}
Before slice = [10 20], Pointer = 0xc4200c0040, len = 2, cap = 4
Before newSlice = [10 20 50], Pointer = 0xc4200c0060, len = 3, cap = 4
After slice = [10 30], Pointer = 0xc4200c0040, len = 2, cap = 4
After newSlice = [10 30 50], Pointer = 0xc4200c0060, len = 3, cap = 4
After array = [10 30 50 40]
情况2：在容量不够用的情况下追加，创建新的底层数组
注意：
因为底层数组修改内容的时候，会影响共同指向同一个底层数组的多个切片
一般在创建新的切片的时候，最好要让新的切片长度和容量一样
这样我们在追加操作的时候就会生成新的底层数组，和原数组分离。 不然会因为共用底层数组而引起奇怪的问题
考点2 append可变函数
append(s S, x ...T) S // T is the element type of S
因为append是一个可变函数，最后一个参数是 ...，可变参数，所以可以append多个参数，也可以append一个slice加上...
s0 := []int{0, 0}
s1 := append(s0, 2) // append a single element s1 == []int{0, 0, 2}
s2 := append(s1, 3, 5, 7) // append multiple elements s2 == []int{0, 0, 2, 3, 5, 7}
s3 := append(s2, s0...) // append a slice s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
s4 := append(s3[3:6], s3[2:]...) // append overlapping slice s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}
var t []interface{}
t = append(t, 42, 3.1415, "foo") // t == []interface{}{42, 3.1415, "foo"}
var b []byte
b = append(b, "bar"...) // append string contents b == []byte{'b', 'a', 'r' }
7.切片拷贝
Slice 中拷贝方法有2个
函数定义
copy(dst, src []T) int
copy(dst []byte, src string) int
举例：
考点1：copy的时候取决于短的那一个
func main() {
array := []int{10, 20, 30, 40}
slice := make([]int, 6)
n := copy(slice, array)
fmt.Println(n,slice) //4 [10,20,30,40]
}
func main() {
slice := make([]byte, 3)
n := copy(slice, "abcdef")
fmt.Println(n,slice) //3 [97,98,99]
}
var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
var s = make([]int, 6)
var b = make([]byte, 5)
n1 := copy(s, a[0:]) // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
n2 := copy(s, s[2:]) // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
n3 := copy(b, "Hello, World!") // n3 == 5, b == []byte("Hello")
8.切片迭代
方法1：for进行迭代
方法2：range进行迭代
如果用 range 的方式去遍历一个切片，拿到的 Value 其实是切片里面的值拷贝。
举例：
func main() {
slice := []int{10, 20, 30, 40}
for index, value := range slice {
fmt.Printf("value = %d , value-addr = %x , slice-addr = %x\n", value, &value, &slice[index])
}
}
value = 10 , value-addr = c4200aedf8 , slice-addr = c4200b0320
value = 20 , value-addr = c4200aedf8 , slice-addr = c4200b0328
value = 30 , value-addr = c4200aedf8 , slice-addr = c4200b0330
value = 40 , value-addr = c4200aedf8 , slice-addr = c4200b0338
从上面结果我们可以看到，如果用 range 的方式去遍历一个切片，拿到的 Value 其实是切片里面的值拷贝。所以每次打印 Value 的地址都不变。
