demo1:切片定义的几种方式

package mainimport "fmt"/*
切片定义的几种方式数组和切片区别：
使用数组传参是值传递，而使用切片传参是引用传递
数组定义好长度之后不可修改，而切片可以理解为动态数组，长度可修改*/func main() {//方法1:直接创建s1 := []string{"1", "2", "3"}fmt.Printf("%T\n", s1)fmt.Println(len(s1))fmt.Println(s1)fmt.Println("--------------------------------------")//方法2:使用make定义，但是需要加上长度,cap可加可不加s2 := make([]string, 3)     //s2:=make([]string, 3,5)   加cap写法fmt.Printf("%T\n", s2)fmt.Println(len(s2))fmt.Println(s2)fmt.Println("--------------------------------------")//方法3：数组变切片arr := [3]string{"1", "2", "3"}s3 := arr[1:2]fmt.Printf("%T\n", s3)fmt.Printf("%T\n", arr)fmt.Println(len(s3))fmt.Println(s3)fmt.Println("--------------------------------------")//方法4：news4 := new([]string)fmt.Printf("%T\n", s4)//fmt.Println(len(s4)) //没有长度fmt.Println(s4) //&[]}

demo2: 切片的基本操作

package mainimport "fmt"/*
切片的基本操作：添加、复制、合并、删除
*/func main() {s1 := []string{"1", "2", "3"}//添加s1 = append(s1, "4", "5")fmt.Println(s1)//复制s2 := []string{}copy(s2, s1)fmt.Println(s2) //这里s2为空，因为没定义长度//拷贝时，目标对象长度为多少就只能复制多少s3 := make([]string, len(s1))copy(s3, s1)fmt.Println(s3)//把两个切片合并s2 = append(s1, s3...) //省略号是规定的参数fmt.Println(s2)//数组中删除元素:先把数组变成切片，再把两个切片合并s4 := s2[:]s4 = append(s2[0:2], s2[4:]...)fmt.Println(s4)
}

demo3: 切片的cap和len

package mainimport "fmt"/*
切片的容量（cap）和长度（len)slice的底层是使用数组实现的，同一个数组的切片会共享内存，但如果切片扩容超过切片的原有容量cap会触发扩容机制，该切片就会自己独立开辟全新内存空间。slice的append扩容问题：扩容阶段因为需要整体开辟全新的内存空间，因此扩容阶段会影响速度。python的list中底层实际上也是数组，也会面临扩容影响速度的问题。python的同一list中可以存不同的数据类型。
*/func main() {//不设置cap时，len和cap大小一致s1 := []string{"1", "2", "3"}fmt.Println(len(s1))    //3fmt.Println(cap(s1))    //3s2 := make([]int, 5)    fmt.Println(len(s2))    //3fmt.Println(cap(s2))    //3s3 := make([]int, 5, 8) //设置了容量capfmt.Println(len(s3))    //5fmt.Println(cap(s3))    //8//通过数组取切片：cap为切片起始位置之后的数组长度s4 := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}s5 := s4[2:5]        fmt.Println(len(s5)) //3fmt.Println(cap(s5)) //8//append函数遇到make问题：如果用make创建切片时定义了长度，append操作会在原有元素之后进行插入。如果没有定义长度，append操作则是对默认元素0进行替换s6 := make([]int, 3)s6 = append(s6, 1)fmt.Println(s6) //[0 0 0 1]s7 := make([]int, 0)s7 = append(s7, 1)fmt.Println(s7) //  [1]}

demo4:切片扩容

案例1：

package mainimport ("fmt"
)func main() {data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组s := data[:2:3]fmt.Println(s)fmt.Println(len(s), cap(s))s = append(s, 100, 200, 300) // 一次 append 三个值，超出 s.cap 限制。fmt.Println(s, data)         // 重新分配底层数组，与原数组无关。fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。}

从输出结果可以看出：append 后的 s 被重新分配了底层数组（也就是说 s 的底层数组不再是 data，那么修改 s 的值不会再影响 data，它们不再有关联），并把原数组中的值拷贝到新数组中。这是因为超出了原切片的容量。在上例中，如果只追加一个值，则不会超过 s.cap 限制，也就不会重新分配。

切片的自动扩容策略是这样的：（文章：简单说说go语言Slice的底层实现_Liuzhiwang29的博客-CSDN博客 简单说说go语言Slice的底层实现 通过分析源码对这一点提出了质疑）通常 以 2 倍容量 进行扩容，并重新分配底层数组（新底层数组的容量也变大）。如果切片的容量小于 1024 个元素，扩容的时候就翻倍增加容量。一旦元素个数超过 1024 个元素，那么增长因子就变成 1.25 ，即每次增加原来容量的四分之一。注意：扩容扩大的容量都是针对原来的容量而言的，而不是针对原来数组的长度而言的。

所以，在大批量添加数据时，建议 一次性分配足够大的空间 ，以减少内存分配和数据复制开销。或 初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收。

slice中 cap 重新分配规律：

package mainimport ("fmt"
)func main() {s := make([]int, 0, 1)fmt.Println(s)c := cap(s)                        //计算容量fmt.Println(c)for i := 0; i < 50; i++ {s = append(s, i)               //按理说 append 第2个元素时就超出了cap，这时会重新分配底层数组来扩大capif n := cap(s); n > c {fmt.Printf("cap: %d -> %d\n", c, n)c = n}}}

输出结果：

[]
1
cap: 1 -> 2
cap: 2 -> 4
cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64

我们可以发现，通常以 2 倍的 cap 重新分配。

提一嘴哈，如果给切片 append 元素时，不超切片容量就没事，操作的还是原数组：

package mainimport ("fmt"
)func main() {data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组s := data[:2:5]                        //将切片容量扩大到5fmt.Println(s)fmt.Println(len(s), cap(s))s = append(s, 100, 200, 300) // 一次 append 三个值，这次没超出 s.cap 限制。fmt.Println(s, data)         fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针}

输出结果：

[0 1]
2 5
[0 1 100 200 300] [0 1 100 200 300 0 0 0 0 0 0]
0xc00004a060 0xc00004a060

案例2：

package mainimport "fmt"//slice的扩容func main() {arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}s1 := arr[2:6]      s2 := s1[3:5]fmt.Printf("s1=%v，len(s1)=%d，cap(s1)=%d\n", s1, len(s1), cap(s1)) //2,3,4,5fmt.Printf("s2=%v，len(s2)=%d，cap(s2)=%d\n", s2, len(s2), cap(s2)) //5,6,为什么s2中取到6，是因为slice支持向后扩容//slice的操作:向slice中添加元素s3 := append(s2, 10)s4 := append(s3, 11)s5 := append(s4, 12)fmt.Println("s3，s4，s5：", s3, s4, s5)fmt.Println("arr：", arr)    //为什么没有11，12?   是因为不能超过cap，如果超过cap则会重新分配一个数组进行存储}