1.简介
切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。切片的使用和数组类似，遍历切片、访问切片的元素和切片的长度都一样。。切片的长度是可以变化的，因此切片是一个可以动态变化的数组。
2.切片的定义基本语法
var 切片名 []类型
比如：var a []int
3.切片的初始化
3.1方式一
第一种方式：定义一个切片，然后让切片去引用一个已经创建好的数组。
var arr = [...]int{1, 2, 3, 4, 5, 6}
slice := arr[1:3]
slice[0] = 100
fmt.Println("arr:", arr)
fmt.Println("slice:", slice)
fmt.Println("slice长度:", len(slice))
fmt.Println("slice容量:", cap(slice))
结果：
arr: [1 100 3 4 5 6]
slice: [100 3]
slice长度: 2
slice容量: 5
根据上面结果分析：切片的确是一个引用类型，改变slice的值会影响原数组。
其实切片底层其实就是一个数据结构
type slice struct{
ptr *[2]int
len int
cap int }
3.2方式二
第二种方式：通过make来创建切片。
基本语法：var 切片名 []type=make([]type ,len,cap)
参数说明：type：就是数据类型 len：大小 cap：值切片的容量，可选，如果你分配了cap，则要求cap>=len。
var SliceA = make([]int, 5, 6)
SliceA[0] = 1
fmt.Println(SliceA) //[0 0 0 0 0]
fmt.Printf("长度：%d-容量%d", len(SliceA), cap(SliceA))
结果：
[1 0 0 0 0]
长度：5-容量6
对上面代码小结：
1.通过make方式创建切片可以指定切片的大小和容量。
2.如果没给切片的各个元素赋值，那么就会使用使用默认值 int 0 float 0 string "" bool false。
3.通过make方式船舰的切片对应的数组由make底层维护，对外不可见，即只能通过slice去访问各个元素。
3.3方式三
定义一个切片，直接指定具体的数组，使用原理类似make的方式。
var strSlice = []string{"java", "php", "golang"}
fmt.Println(strSlice)
fmt.Printf("类型：%T\n", strSlice)
fmt.Println("长度：", len(strSlice))
fmt.Println("容量：", cap(strSlice))
结果：
[java php golang]
类型：[]string
长度： 3
容量： 3
3.4方式一和方式二的区别
1.方式一是直接引用数组，这个数组是事先存在的，程序员可见的。
2.方式二是通过make来创建切片，make也会船舰一个数组，是由七篇在底层进行维护的，程序员是看不见的。make创建切片的示意图：
4.切片的扩容
4.1append扩容
声明一个切片，golang中没办法通过下标方式给切片扩容,需要用到append()方法.比如 var sliceB []int
sliceB[0] = 2 //golang中没办法通过下标方式给切片扩容,需要用到append()方法.
会报错：panic: runtime error: index out of range [0] with length 0
var sliceB []int
sliceB = append(sliceB, 1)
sliceB = append(sliceB, 123, 35, 67)
fmt.Println(sliceB)
fmt.Printf("长度：%v-容量：%v-%v-%T\n", len(sliceB), cap(sliceB), sliceB, sliceB)
结果：
[1 123 35 67]
长度：4-容量：4-[1 123 35 67]-[]int
4.2append方法合并切片
sliceC := []string{"java", "go", "php"}
sliceD := []string{"javad", "god", "phpd"}
sliceC = append(sliceC, sliceD...)
fmt.Println(sliceC)
结果：
[java go php javad god phpd]
4.3切片的copy
已知切片是引用类型，更改切片的值会影响其他使用该切片的地方。
sliceA := []string{"java", "php"}
sleceB := sliceA
var sliceC = make([]string, 2, 2)
//copy()切片的复制
copy(sliceC, sliceA)
sleceB[0] = "golang"
fmt.Println("sliceA:", sliceA)
fmt.Println("sleceB:", sleceB)
fmt.Println("sliceC:", sliceC)
结果：由结果可以看出，当sliceB改变了，对sliceC没有任何影响。
sliceA: [golang php]
sleceB: [golang php]
sliceC: [java php]
4.4切片的删除
删除下标为二的数据。
a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
a = append(a[:2], a[3:]...)
fmt.Println(a)
结果：
[1 2 4 5 6 7 8 9 0]
4.5切片cap容量的理解
切片的容量是从他的第一个元素开始数，到其底层数组元素末尾的个数。
示例1：
a := [8]int{0, 1, 2, 3, 4, 5, 6, 7} // 引用的底层数组
s1 := a[0:5]
fmt.Printf("长度：%v-容量：%v\n", len(s1), cap(s1))
结果：由结果可知长度5容量8，a[0:5],从数组a第一个下标一直数到a数组的末尾个数0-7即cap=8.
长度：5-容量：8
示例2：
a := [8]int{0, 1, 2, 3, 4, 5, 6, 7} // 引用的底层数组
s2 := a[3:6]
fmt.Printf("长度：%v-容量：%v\n", len(s2), cap(s2))
结果：由结果可知长度3容量5，a[3:6],从数组a第一个下标一直数到a数组的末尾个数3-7即cap=5.
长度：3-容量：5
5.切片的遍历
切片的遍历和数组一样，也有两种方式。
方式1：
for i := 0; i < len(slice); i++ {
fmt.Println(slice[i])
}
方式2：
slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
for _, value := range slice {
fmt.Println(value)
}
结果：
1
2
3
4
5
6
7
8
9
6.切片的使用注意事项和细节讨论
7.1切片初始化是var slice=arr[stratIndex:endIndex]
说明：从arr数组小标围殴startIndex，取到下标为endIndex的元素，不包含arr[endIndex]
7.2切片初始化是，仍然不能越界。范围在[0-len(arr)]之间，但可以动态增长。
参考4.1append扩容
7.3cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
参考：4.5切片cap容量的理解
7.4切片定义完后，还不能直接使用，因为本身是一个空的，需要让你、昂起引用到一个数组，或者，make 一个空间供切片使用。
7.5切片可以继续切片
A := []int{1, 2, 3, 4, 5, 6, 7, 8}
B := A[3:8]
C := A[:5]
fmt.Println("B:", B)
fmt.Println("C:", C)
结果：
B: [4 5 6 7 8]
C: [1 2 3 4 5]
7.6append()内置函数，可以对切片进行动态追加
用法：参考4.1、4.2
切片append操作的底层原理分析：
切片append操作的本质就是对数组扩容，go底层会创建新的数组newArr（安装扩容后的大小），
将slice原来包含的元素拷贝到新的数组newArr，slice重新引用到newArr，注意newarr是底层来维护的，程序员不可见。
7.7 关于拷贝的注意事项
var a []int = []int{1, 2, 3, 4, 5}
var slice = make([]int, 1)
copy(slice, a)
fmt.Println(slice)
结果：
[1]
说明，上面代码没有问题，可以运行，最后输出的是[1]