demo1:切片定义的几种方式
package main
import "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：new
s4 := new([]string)
fmt.Printf("%T\n", s4)
//fmt.Println(len(s4)) //没有长度
fmt.Println(s4) //&[]
}demo2: 切片的基本操作
package main
import "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 main
import "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)) //3
fmt.Println(cap(s1)) //3
s2 := make([]int, 5)
fmt.Println(len(s2)) //3
fmt.Println(cap(s2)) //3
s3 := make([]int, 5, 8) //设置了容量cap
fmt.Println(len(s3)) //5
fmt.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)) //3
fmt.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 main
import (
"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 main
import (
"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，这时会重新分配底层数组来扩大cap
if 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 main
import (
"fmt"
)
func main() {
data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组
s := data[:2:5] //将切片容量扩大到5
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]) // 比对底层数组起始指针
}输出结果：文章来源：https://www.toymoban.com/news/detail-687263.html
[0 1]
2 5
[0 1 100 200 300] [0 1 100 200 300 0 0 0 0 0 0]
0xc00004a060 0xc00004a060案例2：文章来源地址https://www.toymoban.com/news/detail-687263.html
package main
import "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,5
fmt.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则会重新分配一个数组进行存储
}到了这里，关于go中的切片的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
