10Go语言——slice

Go语言——slice

[TOC]

一、切片介绍

切片是一种数据结构，这种数据结构便于使用和管理数据集合。切片是围绕动态数组的概念构建的，可以按需自动增长和缩小。切片的动态增长是通过内置函数 append 来实现的。这个函数可以快速且高效地增长切片。还可以通过对切片再次切片来缩小一个切片的大小。因为切片的底层内存也是在连续块中分配的，所以切片还能获得索引、迭代以及为垃圾回收优化的好处。

切片是引用类型，指向底层数组，切片语法和数组很像，只是没有长度而已。slice底层是连续内存，动态增加长度其实如果超过底层数组容量，也会重新分配内存。

• 指向底层的数组，作为变长数组的替代方案，可以关联底层数组的局部或全部
• slice 为引用类型,但自身是结构体，值拷贝传递。
• 如果多个slice指向相同底层数组，其中一个的值改变会影响全部
• 可以直接创建或从底层数组获取生成，一般使用make()创建
• make([]T, len, cap) ,其中cap可以省略，则和len的值相同。
• 属性 len 表示可用元素数量，读写操作不能超过该限制。
• 属性 cap 表示最⼤扩张容量，不能超出数组限制。
• 如果 slice == nil，那么 len、 cap 结果都等于 0。

二、内部实现和原理

struct Slice{ // must not move anything
    byte* array; // actual data
    uintgo len; // number of elements
    uintgo cap; // allocated number of elements
};

切片是有 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] = 25

2、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）append 没有超过原始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.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。可以看大他们的内存地址是不一样的。

（3）append超过容量时，通常以两倍的方式来开辟新的内存

s := make([]int, 0, 1)
c := cap(s)
for i := 0; i < 50; i++ {
    s = append(s, i)
    if n := cap(s); n > c {
        fmt.Printf("cap: %d -> %d\n", c, n)
        c = n
    }
}
//输出
cap: 1 -> 2
cap: 2 -> 4
cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64

在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 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: 40

5、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 的元素