Golang 引用类型 Slice切片

为什么需要切片

---

先看一个需求：我们需要一个数组用于保存学生的成绩，但是学生的个数是不确定的，请问怎么办？

解决方案：使用切片

数组的大小是固定的，把这个数组的空间开大了浪费，开小了不够用，这样就需要使用切片。简单理解就是使用动态的数组。

 

Slice（切片）

---

1）切片的英文是slice

2）切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。

3）切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度len（slice）都一

样。

4）切片的长度是可以变化的，因此切片是一个可以动态变化数组。

5）切片定义的基本语法：var 变量名 [ ]，类型比如： var a [ ]int

切片和数组类似，可以把它理解为动态数组。切片是基于数组实现的，它的底层就是一个数组。对数组任意分隔，就可以得到一个切片。(对于切片的修改可能影响原来的数组)

 

切⽚内部结构

---

这个是容易造成大量GC的数据结构，它也是连续的存储结构，切片其实是一个结构体。

这个结构体包含三个基本元素（指针类型和两个int类型的变量）

• 第一个是一个指针，这个指针指向一片连续的存储空间，也就是数组。(底层数组地址是连续的，所以只要找到开头的内存地址就行了)
• 其次是元素个数，也就是可以访问元素的个数，也就是初始化，设置了值。
• 最后一个就是空间的长度。 

通过下图可以看出，切片是一个具备三个字段的数据结构，分别是指向数组的指针 data，长度 len 和容量 cap：   

切片的本质

---

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap，目前可以存放最多元素的个数，切片容量是可以自动扩容的，动态变化的）。

举个例子，现在有一个数组 a := [8]int{0, 1, 2, 3, 4, 5, 6, 7} ，切片 s1 := a[:5] ，相应示意图如下。

 ([:]这个是取头不取尾)

切片 s2 := a[3:6]，相应示意图如下：

切片的长度就是它所包含的元素个数。

切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。

可以看到切片超过长度的部分赋值给其他变量，那么其他变量可以访问里面所有的元素。 

	array := [8]int{0, 1, 2, 3, 4, 5, 6, 7}
	slice := array[3:6]
	fmt.Println(slice, len(slice), cap(slice))
    [3 4 5] 3 5

//超出len部分的长度是不能访问的！！！！！！！！！！！！！！！！
fmt.Println(slice[4])
panic: runtime error: index out of range [4] with length 3

切⽚声明的四种方式

---

（1）定义一个切片，然后让切片去引用一个已经创建好的数组

（2）声明切片类型，使用append 

var s0 []int
s0 = append(s0, 1)

（3）声明时候直接初始化切片 

s := []int{}
s1 := []int{1, 2, 3}

（4）使用make初始化切片 

s2 := make([]int, 2, 4)

/*  [ ]type, len, cap

   其中len个元素会被初始化为默认零值，未初始化元素不可以访问

*/

数组的底层是不可见的。

切⽚共享存储结构

---

	 var slice2 []int
     for i:=0;i<10;i++{
     	slice2 = append(slice2,i)
     	fmt.Printf("len:%d,cap:%d,address:%p\n",len(slice2),cap(slice2),slice2)

len:1,cap:1,address:0xc0000ae058
len:2,cap:2,address:0xc0000ae060
len:3,cap:4,address:0xc0000b8020
len:4,cap:4,address:0xc0000b8020
len:5,cap:8,address:0xc0000ba040
len:6,cap:8,address:0xc0000ba040
len:7,cap:8,address:0xc0000ba040
len:8,cap:8,address:0xc0000ba040
len:9,cap:16,address:0xc0000bc000
len:10,cap:16,address:0xc0000bc000

当我们不断往里面不断append数据的时候，可以看到切片的长度一直在增长，容量也在增长。可以发现一个规律，容量不够的时候，需要扩容的时候，容量是之前的两倍。

s := append(s,i)而不是append(s,i)，为什么呢，我们只是往s里面去append一个元素，为啥还要重新赋值给s？

看到容量cap的变化你就会明白了，之所以要这么做，是因为结构体里面的指针指向的那一块连续的存储空间地址是发生了一个变化，所以并不是在原有的存储空间不断的添加元素。

当存储空间去扩展的时候，会创建一个新的连续存储空间，并把原有的数值拷贝到新的存储空间里面。

slice用起来很方便，不用像数组一样要去预估大小，可以让其自增长。当时要注意自增长的一个代价，会有存储空间的复制。

slice是一个结构体，一部分是指向了后段的连续存储空间。是不是可以作为一个共享的存储结构，有多个slice，都让他指向同一块存储空间，如下图所示。当两个slice共享了这个结构，其中一个修改了也会对另外一个造成影响。

从开始截取到被截取的最后一个元素，为新切片的cap

   slice5 := []int{0,1,2,3,4,5,6,7,8}
   slice51 := slice5[3:5]
   fmt.Println(slice51,len(slice51),cap(slice51))
   slice52 := slice5[4:6]
   fmt.Println(slice52,len(slice52),cap(slice52))
   slice52[0] = 100
   fmt.Println(slice5,slice51,slice52)


[3 4] 2 6
[4 5] 2 5
[0 1 2 3 100 5 6 7 8] [3 100] [100 5]

基于数组生成切片
下面代码中的 array[2:5] 就是获取一个切片的操作，它包含从数组 array 的索引 2 开始到索引 5 结束的元素：

array:=[5]string{"a","b","c","d","e"}
slice:=array[2:5]
fmt.Println(slice)

注意：这里是包含索引 2，但是不包含索引 5 的元素，即在 : 右边的数字不会被包含。

//基于数组生成切片，包含索引start，但是不包含索引end
slice:=array[start:end]

所以 array[2:5] 获取到的是 c、d、e 这三个元素，然后这三个元素作为一个切片赋值给变量 slice。

切片和数组一样，也可以通过索引定位元素。这里以新获取的 slice 切片为例，slice[0] 的值为 c，slice[1] 的值为 d。

有没有发现，在数组 array 中，元素 c 的索引其实是 2，但是对数组切片后，在新生成的切片 slice 中，它的索引是 0，这就是切片。虽然切片底层用的也是 array 数组，但是经过切片后，切片的索引范围改变了。 

这里有一些小技巧，切片表达式 array[start:end] 中的 start 和 end 索引都是可以省略的，如果省略 start，那么 start 的值默认为 0，如果省略 end，那么 end 的默认值为数组的长度。如下面的示例：

1. array[:4] 等价于 array[0:4]。

2. array[1:] 等价于 array[1:5]。

3. array[:] 等价于 array[0:5]。

 切片修改

切片的值也可以被修改，这里也同时可以证明切片的底层是数组。

对切片相应的索引元素赋值就是修改，在下面的代码中，把切片 slice 索引 1 的值修改为 f，然后打印输出数组 array：

slice:=array[2:5]
slice[1] ="f"
fmt.Println(array)

可以看到如下结果：

[a b c f e]

数组对应的值已经被修改为 f，所以这也证明了基于数组的切片，使用的底层数组还是原来的数组，一旦修改切片的元素值，那么底层数组对应的值也会被修改。 

切片声明

除了可以从一个数组得到切片外，还可以声明切片，比较简单的是使用 make 函数。

下面的代码是声明了一个元素类型为 string 的切片，长度是 4，make 函数还可以传入一个容量参数：

slice1:=make([]string,4)

 在下面的例子中，指定了新创建的切片 []string 容量为 8：

slice1:=make([]string,4,8)

这里需要注意的是，切片的容量不能比切片的长度小。

切片的长度你已经知道了，就是切片内元素的个数。那么容量是什么呢？其实就是切片的空间。

上面的示例说明，Go 语言在内存上划分了一块容量为 8 的内容空间（容量为 8），但是只有 4 个内存空间才有元素（长度为 4），其他的内存空间处于空闲状态，当通过 append 函数往切片中追加元素的时候，会追加到空闲的内存上，当切片的长度要超过容量的时候，会进行扩容。

	var slice2 []string
	slice2 = make([]string,3,10)
	fmt.Println(slice2)
	slice2 = append(slice2,"f")
	fmt.Println(slice2)

切片不仅可以通过 make 函数声明，也可以通过字面量的方式声明和初始化，如下所示：

slice1:=[]string{"a","b","c","d","e"}
fmt.Println(len(slice1),cap(slice1))

可以注意到，切片和数组的字面量初始化方式，差别就是中括号 [ ] 里的长度。此外，通过字面量初始化的切片，长度和容量相同。

Append

我们可以通过内置的 append 函数对一个切片追加元素，返回新切片，如下面的代码所示：

//追加一个元素
slice2:=append(slice1,"f")

//多加多个元素
slice2:=append(slice1,"f","g")

//追加另一个切片
slice2:=append(slice1,slice...)

append 函数可以有以上三种操作，你可以根据自己的实际需求进行选择，append 会自动处理切片容量不足需要扩容的问题。

小技巧：在创建新切片的时候，最好要让新切片的长度和容量一样，这样在追加操作的时候就会生成新的底层数组，从而和原有数组分离，就不会因为共用底层数组导致修改内容的时候影响多个切片。 

	var arry10 [5]int
	arry10 = [5]int{1,2,3,4,5}

	var slice10 []int
	slice10 = make([]int,5,5)
	slice10 = arry10[:]
	slice10 = append(slice10, 8)
	fmt.Println("array10",arry10)
    fmt.Println("slice10",len(slice10),cap(slice10),slice10)


array10 [1 2 3 4 5]
slice10 6 10 [1 2 3 4 5 8]

切片元素循环

切片的循环和数组一模一样，常用的也是 for range 方式，这里就不再进行举例。

在 Go 语言开发中，切片是使用最多的，尤其是作为函数的参数时，相比数组，通常会优先选择切片，因为它高效，内存占用小。

数组 vs. 切⽚

---

1. 容量是否可伸缩

2. 是否可以进⾏⽐较：对于相同维数，相同长度的数组是可以比较的，只要里面元素的值一样就可以认为都两个数组相同。slice只能和nil空来进行比较，是不能进行slice == slice2 进行比较的。 

slice4 := make([]string, 4, 8)
	if slice4 == nil {
		fmt.Println("slice4 nil")
	} else {
		fmt.Println("slice4 not nil")
	}

var slice5 []string
	if slice5 == nil {
		fmt.Println("slice5 nil")
	} else {
		fmt.Println("slice5 not nil")
	}

slice4 not nil
slice5 nil