Go语言slice切片详解
Go语言——slice
一、切片介绍
切片是一种数据结构，这种数据结构便于使用和管理数据集合。切片是围绕动态数组的概念构建的，可以按需自动增长和缩小。切片的动态增长是通过内置函数 append 来实现的。这个函数可以快速且高效地增长切片。还可以通过对切片再次切片来缩小一个切片的大小。因为切片的底层内存也是在连续块中分配的，所以切片还能获得索引、迭代以及为垃圾回收优化的好处。
切片是引用类型，指向底层数组，切片语法和数组很像，只是没有长度而已。slice底层是连续内存，动态增加长度其实如果超过底层数组容量，也会重新分配内存。
- 指向底层的数组，作为变长数组的替代方案，可以关联底层数组的局部或全部
- slice 为引用类型,但自身是结构体，值拷贝传递。
- 如果多个slice指向相同底层数组，其中一个的值改变会影响全部
- 可以直接创建或从底层数组获取生成，一般使用make()创建
- make([]T, len, cap) ,其中cap可以省略，则和len的值相同。
- 属性 len 表示可用元素数量，读写操作不能超过该限制。
- 属性 cap 表示最⼤扩张容量，不能超出数组限制。
- 如果 slice == nil，那么 len、 cap 结果都等于 0。
二、内部实现和原理
type slice struct {
array unsafe.Pointer
len int
cap int
}切片是有 3 个字段的数据结构 ，这 3 个字段分别是指向底层数组的指针、切片访问的元素的个数（即长度）和切片允许增长到的元素个数（即容量）。
可以看出，slice是引用类型。时刻注意一点，slice传递的时候也是值拷贝，把slice的指针，长度，容量拷贝过去，那么同样可以去操作底层数组
三、创建和初始化
1、普通初始化（var或者：= ,字面量）
var slice[]int //只声明一个slice,len 和 cap 都是0
var slice0 []int=[]int{1,2,3}//完整声明，字面量初始化
var slcie1=[]int{1,2,3} //直接var 字面量初始化
slice2:=[]int{1,2,3}//函数内部可以用:=替代var 初始化2、使用make() 函数进行初始化
一般使用make()进行创建 make([]T, len, cap) 指定类型，长度，容量，make()会在按照容量分配内存空间，也就是分配的数组
slice:=make([]string,5)//使用长度声明一个字符串切片，长度、容量都是5
slice0:=make([]int,3,5)//使用长度和容量声明int切片，长度为3，容量为5容量小于长度的切片会在编译时报错
slice := make([]int, 5, 3)//注意，不允许,注意：使用make([]int,3,5)创建slice,指定的容量cap 其实就是初始化的底层数组的长度。但是此slice 长度为3，只能操作底层数组的前3个，后两个是不能操作的，但是可以通过append函数添加到此slice中。如果基于这个切片创建新的切片，新切片会和原有切片共享底层数组，也能通过后期操作(如append)来访问多余容量的元素。
3、使用索引声明切片
// 创建字符串切片
// 使用空字符串初始化第 100 个元素
slice := []string{99: ""}记住，如果在[]运算符里指定了一个值，那么创建的就是数组而不是切片。只有不指定值的时候，才会创建切片 。这里字面量声明索引为99的位置为空字符串，所以，长度和容量都是 100 个元素，最少开辟了100个内存空间。
4、从数组创建slice
（1）通过两个冒号创建切片，slice[x:y:z]切片实体[x:y]切片长度len = y-x，切片容量cap = z-x
data := [...]int{0, 1, 2, 3, 4, 5, 6} //初始化一个数组
slice := data[1:4:5] // [low : high : max] 通过两个冒号创建切片使用两个冒号[1:4:5] 从数组中创建切片，长度为4-1=3，也就是索引从1到3 的数据（1,2,3），然后，后面是最大是5，即容量是5-1=4，即，创建的切片是长度为从索引为 1、2、3 的切片，底层数组为[ 1,2,3,4]
（2）通过单个冒号，索引创建slice
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
expression slice len cap comment
------------ ---------------------- ------ ------- ---------------------
data[:6:8] [0 1 2 3 4 5] //6 8 省略 low.
data[5:] [5 6 7 8 9] //5 5 省略 high、 max。
data[:3] [0 1 2] //3 10 省略 low、 max。
data[:] [0 1 2 3 4 5 6 7 8 9] //10 10 全部省略。5、创建空的slice
首先说一下，slice和array的区别，其实就是[]中有没有值，有值就是数组，无值就是slice
// 使用 make 创建空的整型切片
slice := make([]int, 0)
// 使用切片字面量创建空的整型切片
slice := []int{}空切片在底层数组包含 0 个元素，也没有分配任何存储空间。想表示空集合时空切片很有用.
例如，数据库查询返回 0 个查询结果时
四、切片的使用
1、直接用索引赋值
// 创建一个整型切片
// 其容量和长度都是 5 个元素
slice := []int{10, 20, 30, 40, 50}
// 改变索引为 1 的元素的值
slice[1] = 252、reslice 也就是通过slice创建 slice
s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s[2:5] // [2 3 4]
s2 := s1[2:6:7] // [4 5 6 7]
s3 := s2[3:6] // Error。 不能超过父slice的容量。
//索引s[2:5] 表示从索引2开始，到索引4结束，包括2但是不包括5 
- s1:=s[2:5] 得到的是len为 5-2=3， cap为10-2=8。 这个公式 可以计算。 所以，s1指向底层数组的从第二个索引开始，三个长度的内存，2,3,4. 但是他的容量cap为8，也就是，s1指向内存起始位置是原数组的2，一直到9，都是一块连续的内存。如果要增加s1的长度，不需要开辟新的内存空间，只需要往s1里面添加就行，他继续指向这块内存地址，直到他的长度超过容量，就会重新开辟内存空间。
- s2:=s1[2:6:7] ,s2是通过s1创建的新的slice，它同样指向了和s1，s1一样的底层数组，只不过是起始的索引位置不同。s2表示从s1索引为2开始到索引为5的长度为4个的slice，并且还指定了他的容量为7，也就是它不使用它起始索引到底层数组末尾的长度作为容量，而是使用自己指定的容量7. 如图，s1长度为3，而s2的长度为4，并且是从s1索引为2开始的，但是却没有报错。 是因为，reslice,是根据 子slice相对于父slice的容量创建的，只要子slice的长度没有超过父slice的容量，那么就是允许的，因为他们指向的是同一个底层数组。
- 所以，s3:=s2[3:6] 他报错了。因为s3是创建 从s2作为为3，长度为3的slice，但是s2的长度为4，容量为5，从索引3开始算，s2只能最大创建出长度为2的 子slice，不能创建出长度为3的slice
- 总结下，就是，父slice 和子slice 都是指向了同一块连续内存，底层是个数组。 只是根据长度和容量的不同，创建的slice 允许操作的内存块是不同的。如果子slice创建时不指定自己的容量cap,那么它的容量默认为，从他指向的那个底层数组的索引开始，一直到这个数组的最末端。这块是它的容量，也就是它创建以后，可以继续扩展而不改变内存地址。注意，它可以操作的连续内存是由它的长度决定的。比如，长度为3，容量为5,的slice，它只能操作从它指向底层数组的那个首索引开始，往后三个数，另外两个是不允许操作的。
由于reslice 的slice指向了同一块连续内存空间，所以操作是会相互影响的
// 创建一个整型切片
// 其长度和容量都是 5 个元素
slice := []int{10, 20, 30, 40, 50}
// 创建一个新切片
// 其长度是 2 个元素，容量是 4 个元素 {20,30}
newSlice := slice[1:3]
// 修改 newSlice 索引为 1 的元素
// 同时也修改了原来的 slice 的索引为 2 的元素
newSlice[1] = 35
//最终底层为 {10,35,30,40,50}3、append 增长slice
相对于数组而言，使用切片的一个好处是，可以按需增加切片的容量。 函数 append 总是会增加新切片的长度，而容量有可能会改变，也可能不会改变，这取决于被操作的切片的可用容量。 (也就是，如果容量够直接加，不够重新分配内存，拷贝原数组加)
（1）向 slice 尾部添加数据，返回新的 slice 对象。
s := make([]int, 0, 5)
fmt.Printf("%p\n", &s)
s2 := append(s, 1)
fmt.Printf("%p\n", &s2)
fmt.Println(s, s2)
//输出结果
0xc000004440
0xc000004480
[] [1] append函数做的事就是更改slice指向底层数组的值
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[:3]
s2 := append(s, 100, 200) // 添加多个值。
fmt.Println(data)
fmt.Println(s)
fmt.Println(s2)
//输出----------append函数更改了slice执行底层数组data，增加了s的长度，并将相应位置的值改变
[0 1 2 100 200 5 6 7 8 9]
[0 1 2]
[0 1 2 100 200]（2） 未超过原slice容量，底层数组不会重新分配
package main
import "fmt"
func main(){
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[:2:3] //长度为1，容量为3
fmt.Printf("len: %d,cap: %d\n",len(s),cap(s))
fmt.Printf("原地址对比\n%p\n%p\n",&data[0],&s[0])
s2 := append(s, 100) // 添加1一个值，未超过容量
fmt.Printf("len: %d,cap: %d\n",len(s2),cap(s2))
fmt.Printf("未超过容量时地址对比\n%p\n%p\n",&data[0],&s2[0])
s3 := append(s2, 200) // 再次添加一个值，超过容量3
fmt.Printf("len: %d,cap: %d\n",len(s3),cap(s3))
fmt.Printf("超过容量时地址对比\n%p\n%p\n",&data[0],&s3[0])
}
//输出
len: 2,cap: 3
原地址对比
0xc00008e000
0xc00008e000
len: 3,cap: 3
未超过容量时地址对比
0xc00008e000
0xc00008e000
len: 4,cap: 6
超过容量时地址对比
0xc00008e000
0xc00007e030（3）但是，一旦超出原 slice.cap 限制，就会重新分配底层数组，即便原数组并未填满。
data := [...]int{0, 1, 2, 3, 4, 10: 0}
s := data[:2:3]
s = append(s, 100, 200) // ⼀次 append 两个值，超出 s.cap 限制。
fmt.Println(s, data) // 重新分配底层数组，与原数组无关。
fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。
//输出
[0 1 100 200] [0 1 2 3 4 0 0 0 0 0 0]
0xc00007e030 0xc00004a060上面代码表示，切片s 的长度为2，容量为3，而s通过append一次性添加两个值，也就是想把s变为长度为4的切片，这超过了s的原始容量，所以，这样append会重新开辟一段内存地址，长度为4，容量为4。可以看大他们的内存地址是不一样的。
（4）append超过容量时，由增长因子决定开辟多大新内存
s := make([]int, 0, 1)
c := cap(s)
for i := 0; i < 1000000; i {
s = append(s, i)
if n := cap(s); n > c {
fmt.Printf("cap: %d -> %d %.2f\n", c, n,float32(n)/float32(c))
c = n
}
}
//输出
cap: 1 -> 2 2.00
cap: 2 -> 4 2.00
cap: 4 -> 8 2.00
cap: 8 -> 16 2.00
cap: 16 -> 32 2.00
cap: 32 -> 64 2.00
cap: 64 -> 128 2.00
cap: 128 -> 256 2.00
cap: 256 -> 512 2.00
cap: 512 -> 1024 2.00
cap: 1024 -> 1280 1.25
cap: 1280 -> 1696 1.33
cap: 1696 -> 2304 1.36
cap: 2304 -> 3072 1.33
cap: 3072 -> 4096 1.33
cap: 4096 -> 5120 1.25
cap: 5120 -> 7168 1.40
cap: 7168 -> 9216 1.29
cap: 9216 -> 12288 1.33
cap: 12288 -> 15360 1.25
cap: 15360 -> 19456 1.27
cap: 19456 -> 24576 1.26
cap: 24576 -> 30720 1.25
cap: 30720 -> 38912 1.27
cap: 38912 -> 49152 1.26
cap: 49152 -> 61440 1.25
cap: 61440 -> 76800 1.25
cap: 76800 -> 96256 1.25
cap: 96256 -> 120832 1.26
cap: 120832 -> 151552 1.25
cap: 151552 -> 189440 1.25
cap: 189440 -> 237568 1.25
cap: 237568 -> 296960 1.25
cap: 296960 -> 371712 1.25
cap: 371712 -> 464896 1.25
cap: 464896 -> 581632 1.25
cap: 581632 -> 727040 1.25
cap: 727040 -> 909312 1.25
cap: 909312 -> 1136640 1.25从输出看，容量最开始以2倍的方式进行开辟，数据量越大，增长因子会稳定在1.25左右。
一旦元素个数超过 1000，容量的增长因子会设为 1.25左右，也就是会每次增加 25%的容量。随着语言的演化，这种增长算法可能会有所改变。
在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收。
但是如果是要避免多个slice同时操作同一内存出现错误时，就需要将将slice创建为长度=容量，避免append新slice指向同一内存操作数据，具体情况根据实际灵活选择。
（5）将一个切片追加到另一个切片 ,使用...运算符
// 创建两个切片，并分别用两个整数进行初始化
s1 := []int{1, 2}
s2 := []int{3, 4}
// 将两个切片追加在一起，并显示结果
fmt.Printf("%v\n", append(s1, s2...)) //使用... 就可以
//输出:
[1 2 3 4]
//就像通过输出看到的那样，切片 s2 里的所有值都追加到了切片 s1 的后面。使用 Printf时用来显示 append 函数返回的新切片的值4、使用for range 迭代slice
// 创建一个整型切片
// 其长度和容量都是 4 个元素
slice := []int{10, 20, 30, 40} // 迭代每一个元素，并显示其值
for i, v := range slice {
fmt.Printf("Index: %d Value: %d\n", i, v)
}
//输出
Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40关键字 range 会返回两个值。第一个值是当前迭代到的索引位置，第二个值是该位置对应元素值的一份拷贝
// 创建一个整型切片
// 其长度和容量都是 4 个元素
slice := []int{10, 20, 30, 40}
// 迭代每个元素，并显示值和地址
for index, value := range slice {
fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X\n",
value, &value, &slice[index])
}
//输出:-----明显看出内存地址不同，所以这里的v，是拷贝，其实只是一个内存地址不断更新存不同的拷贝
Value: 10 Value-Addr: C000058058 ElemAddr: C0000560C0
Value: 20 Value-Addr: C000058058 ElemAddr: C0000560C8
Value: 30 Value-Addr: C000058058 ElemAddr: C0000560D0
Value: 40 Value-Addr: C000058058 ElemAddr: C0000560D8因为迭代返回的变量是一个迭代过程中根据切片依次赋值的新变量，所以 value 的地址总是相同的。要想获取每个元素的地址，可以使用切片变量和索引值
迭代返回索引和位置非常有用，如果我们只想用其中一个，可以通过占位符 “_” 操作
slice := []int{10, 20, 30, 40}
for _, value := range slice {// 迭代每个元素，并显示其值，通过占位符，不需要得到索引
fmt.Printf("Value: %d\n", value)
}
//输出:
Value: 10
Value: 20
Value: 30
Value: 405、copy 复制slice
函数 copy 在两个 slice 间复制数据，复制长以 len 小的为准。两个 slice 可指向同一底层数组，允许元素区间重叠。
（1）不指定位置
s1 := []int{1, 2, 3, 4, 5, 6}
s2 := []int{7, 8, 9}
fmt.Println(s2)
copy(s2, s1) //将s1 copy到 s2, 谁的长度小听谁的，此处只能拷贝前三个
fmt.Println(s2)
//输出------长度大的往长度小的复制最大只能复制以小长度为准的位数
[7 8 9]
[1 2 3]
（2）指定位置
还可以指定复制slice 和被复制slice 的位置进行copy，不指定默认从前往后，如上面代码
s1 := []int{0,1, 2, 3, 4, 5, 6}
s2 := []int{7, 8, 9}
fmt.Println("s1=",s1)
fmt.Println("s2=",s2)
copy(s1[4:6], s2[1:3]) //将s2指定位置复制到s1指定的位置
fmt.Println("s1=",s1)
//输出
s1= [0 1 2 3 4 5 6]
s2= [7 8 9]
s1= [0 1 2 3 8 9 6]（3）注意，copy以后的数组，指向的底层数组也会随之改变
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[8:]
s2 := data[:5]
copy(s2, s) // dst:s2, src:s
fmt.Println(s2)
fmt.Println(data)
//输出
[8 9 2 3 4]
[8 9 2 3 4 5 6 7 8 9]6、切片的传递
切片的传递，都是值传递，是切片的拷贝
在 64 位架构的机器上，一个切片需要 24 字节的内存：指针字段需要 8 字节，长度字段需要8字节，容量字段需要 8 字节。由于与切片关联的数据包含在底层数组里，不属于切片本身，所以将切片复制到任意函数的时候，对底层数组大小都不会有影响。复制时只会复制切片本身，不会涉及底层数组 。所以不管多大的slice，值传递都不会影响性能。
五、多维切片
多维切片和多维数组差不多，只不过[]没有值
// 创建一个整型切片的切片
slice := [][]int{{10}, {100, 200}}
使用append 给slice[0]进行增长，查看内存变化
// 创建一个整型切片的切片
slice := [][]int{{10}, {100, 200}}
// 为第一个切片追加值为 20 的元素
slice[0] = append(slice[0], 20)以上代码会先增长切片，会为新的整型切片分配新的底层数组，然后将切片复制到外层切片的索引为 0 的元素 
您可能感兴趣的文章：
想系统学习GO语言(Golang
[go语言]-slice实现的使用和基本原理
切片 里面包含interface_Golang数据结构详解之切片
Go语言切片详解
golang切片内存应用技巧
golang面试题
11.深入理解切片(slice)
Golang的数组与切片——详解
Go如何对数组切片进行去重
Go语言发展历史、核心、特性及学习路线