基础
1 .切片可以按需自动扩充和缩减
2 .底层是通过内建函数append来实现的
3 .切片的三个属性
1 .指针：指向数组的第一个可以从切片访问的元素，这个元素不一定是数组的第一个元素
2 .长度：长度是切片中的元素个数，他不能超过切片的容量。go的内建函数可以返回切片的长度
3 .容量：从切片的起始元素到底层数组的最后一个元素间，元素的个数，cap()可以返回切片的容量
type slice struct{
ptr *[2]int
len int
cap int
}
4 .切片是数组的一个引用，所以是引用类型，在进行传递的时候，遵守引用传递守则
5 .切片的长度是变化的，因此切片是可以动态变化的数组
6 .len:返回数组切片当前存储的元素个数
7 .cap:返回数组切片分配的空间的大小
8 .append:如果底层数组中还有额外的容量可用，那么append将可用的元素合并到切片的长度，并对其赋值。如果切片的底层数组没有足够的可用容量，那么append函数会创建一个新的底层数组，将被引用的现有的值复制到新数组中，在追加新的值。
9 .append会智能的处理底层数组的容量增长，当容量小于1000，会翻倍的增长，当大于1000时，1.25倍增长。
10 .切片是对数组的一个连续片段的引用。所以切片是一个引用类型。这个片段可以是整个数组，也可以是由起使和终止索引标识的一些项的子集
11 .切片默认指向一段连续的内存
12 .a[0:0]:重置切片
13 .使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。
创建和初始化
1 .基于数组
var slice2 []int=[]int{1,2,3}
//好像是需要这样才行
var a []int
// 切片名称是a,切片数据类型是int类型
arr:=[...]int{1,2,3,4,5}
//定义的数组
a=arr[1:3]
//赋值给切片
//注意：数组创建的切片会互相干扰
var a []int
// 切片名称是a,切片数据类型是int类型
arr:=[...]int{1,2,3,4,5}
a=arr[1:3]
fmt.Println(a)
arr[1]=10
fmt.Println(a)
a[1]=100
fmt.Println(arr)
2 .直接创建
var slice1 []int=make([]int,4,10)
这样也会创建一个数组，但是这个数组对外是不可见的，只能通过slice去操作，而不能通过数组来操作
3 .使用切片创建切片
slice:=[]int{1,2,3}
slice1:=slice[:1]
slice2:=slice[1:]
//1，2共享同一段底层数组，但是不同的切片看到的内容是不一样的
//1只能看到第一个，2只能看到第一个之后的元素，他是无法访问到第一个元素的，所以对于2来说，第一个元素是不存在的
//当两个切片共享了一个底层数组时，如果一个切片修改了改底层数组的共享部分，那么另一个切片也会发生改变
//切片只能访问到其长度内的元素，试图范根超出其长度的元素将会导致异常。
切片赋值
1 .对切片某个索引指向的元素赋值和数组操作一模一样
2 .
append
1 .slice1=append(slice1,slice1...)
2 .slice1=append(slice1,100,200)
3 .需要原来的切片来接收
4 .切片append操作的本质就是对数组扩容
// 3.2go底层会创建一个新的数据newArray
// 3.3将slice原来包含的元素拷贝到新的数组newArray
// 3.4slice重新引用到newArr
// 3.5注意，newArray是在底层来维护的，程序员不可见
删除
a:=[]int{1,2,3,4,5}
fmt.Println(a)
a=append(a[:2],a[2+1:]...)
// 他是这样删除数据的，把两个新的拼起来。这个例子就是删除了第二个数据
fmt.Println(a)
复制
a:=[]int{1,2,3,4,5}
b:=make([]int,10)
fmt.Println(b)
copy(b,a)
fmt.Println(b)
// 必须要先make出来，才能复制进去
string和slice的关系
1 .
添加元素
// var a []int
// a=append(a,1)
// fmt.Println(a)
// a=append(a,1,2,3)
// fmt.Println(a)
// a=append(a,[]int{1,2,3}...)
// 需要解构切片
// fmt.Println(a)
// 开头添加元素
var b []int=[]int{1,2,3}
b=append([]int{0},b...)
// 开头添加一个0
fmt.Println(b)
// 在切片开头添加元素会导致内存重新分配，而且会导致已有元素全部被复制一次，因此，从切片开头添加元素的
// 的性能比
// append链式操作:在任意一个地方插入元素
var c []int=[]int{1,2,3}
c=append(c[:1],append([]int{10},c[1:]...)...)
fmt.Println(c)
复制元素
a:=[]int{1,2,3}
b:=[]int{1}
b=make([]int,10)
// 必须要make分配内存才能copy成功
copy(b,a)
// 把a的元素复制到b
删除元素
// 删除的本质:已被删除的元素位分界点，将前后两部分的内存重新连接起来
// 连续容器的元素删除无论在任何语言中，都挺要将删除点前后的元素移动到新的位置，随着元素的增加，这个过程将会变得
// 极为耗时，因此当业务需要大量，频繁的从一个切片中删除元素时，对性能要求极高的话，需要考虑别的容器，比如双链表
// a:=[]int{1,2,3,4,5}
// // 从开头删除，移动指针
// a=a[1:]
// // 删除第一个
// fmt.Println(a)
// // 从尾部删除
// // 删除末尾一个元素
// a=a[:len(a)-1]
// fmt.Println(a)
// a=a[:len(a)-n]
// 删除n个元素
// 从中间删除
// 需要对剩余的元素进行一次整体挪动，appen,copy方法都可以
b:=[]int{1,2,3,4,5,6}
b=append(b[:1],b[1+1:]...)
// 从第二个元素开始，向后删除一个
// b=append(b[:n],b[n+x])
// 从n开始，向后删除x个元素
// 这些可以封装成函数了
fmt.Println(b)
