7. 切片 sice

7.1 切片基础

7.1.1 切片定义

切片（Slice）是==一个拥有相同类型元素的可变长度的序列。==它是基于数组类型做的一层封装。非常灵活，支持自动扩容。切片是一个引用类型，它的内部结构包含地址、长度和容量。

声明切片类型的基本语法如下：

==var name []T==

• name：表示变量名
• T：表示切片中的元素类型

与数组声明相比，切片声明仅仅是少了一个“长度”属性。去掉“长度”这一束缚后，切片展现出更为灵活的特性。

package main

import "fmt"

func main() {
   // 切片是引用类型，不支持直接比较，只能和 nil 比较
   var a []string        //声明一个字符串切片
   fmt.Println(a)        //[]
   fmt.Println(a == nil) //true

   var b = []int{}       //声明一个整型切片并初始化
   fmt.Println(b)        //[]
   fmt.Println(b == nil) //false

   var c = []bool{false, true} //声明一个布尔切片并初始化
   fmt.Println(c)              //[false true]
   fmt.Println(c == nil)  //false

}

切片之间是不能比较的，我们不能使用 == 操作符来判断两个切片是否含有全部相等元素。切片唯一合法的比较操作是和 nil 比较。 一个 nil 值的切片并没有底层数组，一个 nil 值的切片的长度和容量都是 0。但是我们不能说一个长度和容量都是 0 的切片一定是 nil。

还可以用以下几种方法创建切片，并指定它底层数组的长度：

方法一：通过 make 函数来创建切片，并指定底层数组的长度。

// 其中10为cap值，即底层数组长度，6为切片的初始长度
sl := make([]byte, 6, 10) 

// 如果没有在 make 中指定 cap 参数，那么底层数组长度 cap 就等于 len
sl := make([]byte, 6) // cap = len = 6

方法二：采用 array[low : high : max]语法基于一个已存在的数组创建切片。这种方式被称为数组的切片化。

arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
sl := arr[3:7:9]

我们基于数组 arr 创建了一个切片 sl，这个切片 sl 在运行时中的表示是这样：

// 如果我们将切片的第一个元素加 10，那么数组 arr 的第四个元素将变为 14：
sl[0] += 10
fmt.Println("arr[3] =", arr[3]) // 14

==切片好比打开了一个访问与修改数组的“窗口”，==通过这个窗口，可以直接操作底层数组中的部分元素。这有些类似于我们操作文件之前打开的“文件描述符”（Windows 上称为句柄），通过文件描述符我们可以对底层的真实文件进行相关操作。可以说，==切片之于数组就像是文件描述符之于文件。==

在进行数组切片化的时候，通常省略 max，而 max 的默认值为数组的长度。

针对一个已存在的数组，我们还==可以建立多个操作数组的切片，这些切片共享同一底层数组==，切片对底层数组的操作也同样会反映到其他切片中。下面是为数组 arr 建立的两个切片的内存表示：

方法三：基于切片创建切片。

7.1.2 切片本质

==切片的本质就是对底层数组的封装。==

它包含了三个信息：底层数组的指针（切片名称）、切片的长度（len）和切片的容量（cap）。cap 值永远大于等于 len 值。

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

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

7.1.3 切片的长度和容量

切片拥有自己的长度和容量。通过使用内置的 len()函数求长度，使用内置的 cap()函数求切片的容量。

• 切片的长度：所包含的元素个数。
• 切片的容量：从它的第一个元素开始数，到其底层数组元素末尾的个数。

切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

package main

import "fmt"

func main() {
   s := []int{2, 3, 5, 7, 11, 13}
   fmt.Printf("长度： %v 容量： %v \n", len(s), cap(s)) // 长度:6 容量 6
}

7.1.4 切片的动态扩容

“动态扩容”指的就是：当我们通过 append 操作向切片追加数据的时候，如果这时切片的 len 值和 cap 值是相等的，也就是说切片底层数组已经没有空闲空间再来存储追加的值了，Go 运行时就会对这个切片做扩容操作，来保证切片始终能存储下追加的新值。

var s []int
s = append(s, 11) 
fmt.Println(len(s), cap(s)) //1 1
s = append(s, 12) 
fmt.Println(len(s), cap(s)) //2 2
s = append(s, 13) 
fmt.Println(len(s), cap(s)) //3 4
s = append(s, 14) 
fmt.Println(len(s), cap(s)) //4 4
s = append(s, 15) 
fmt.Println(len(s), cap(s)) //5 8

针对元素是 int 型的数组，新数组的容量是当前数组的 2 倍。新数组建立后，append 会把旧数组中的数据拷贝到新数组中，之后新数组便成为了切片的底层数组，旧数组会被垃圾回收掉。

不过 append 操作的这种自动扩容行为，有些时候会给我们开发者带来一些困惑，比如基于一个已有数组建立的切片，一旦追加的数据操作触碰到切片的容量上限（实质上也是数组容量的上界)，切片就会和原数组解除“绑定”，后续对切片的任何修改都不会反映到原数组中了。我们再来看这段代码：

u := [...]int{11, 12, 13, 14, 15}
fmt.Println("array:", u) // [11, 12, 13, 14, 15]
s := u[1:3]
fmt.Printf("slice(len=%d, cap=%d): %v\n", len(s), cap(s), s) // [12, 13]
s = append(s, 24)
fmt.Println("after append 24, array:", u)
fmt.Printf("after append 24, slice(len=%d, cap=%d): %v\n", len(s), cap(s), s)
s = append(s, 25)
fmt.Println("after append 25, array:", u)
fmt.Printf("after append 25, slice(len=%d, cap=%d): %v\n", len(s), cap(s), s)
s = append(s, 26)
fmt.Println("after append 26, array:", u)
fmt.Printf("after append 26, slice(len=%d, cap=%d): %v\n", len(s), cap(s), s)

s[0] = 22
fmt.Println("after reassign 1st elem of slice, array:", u)
fmt.Printf("after reassign 1st elem of slice, slice(len=%d, cap=%d): %v\n", len(s), cap(s), s)

/*
array: [11 12 13 14 15]
slice(len=2, cap=4): [12 13]
after append 24, array: [11 12 13 24 15]
after append 24, slice(len=3, cap=4): [12 13 24]
after append 25, array: [11 12 13 24 25]
after append 25, slice(len=4, cap=4): [12 13 24 25]
after append 26, array: [11 12 13 24 25]
after append 26, slice(len=5, cap=8): [12 13 24 25 26]
after reassign 1st elem of slice, array: [11 12 13 24 25]
after reassign 1st elem of slice, slice(len=5, cap=8): [22 13 24 25 26]
*/

7.2 切片循环

切片的循环遍历和数组的循环遍历是相同的。

7.2.1 基本遍历

package main

import "fmt"

func main() {
   var a = []string{"北京", "上海", "深圳"}
   for i := 0; i < len(a); i++ {
      fmt.Println(a[i])
   }
}

/*
北京
上海
深圳
*/

7.2.2 K/V遍历

package main

import "fmt"

func main() {
   var a = []string{"北京", "上海", "深圳"}
   for index, value := range a {
      fmt.Println(index, value)
   }
}

/*
0 北京
1 上海
2 深圳
*/

7.3 append()

Go 语言的内建函数 append()可以为切片动态添加元素。

每个切片会指向一个底层数组，如果这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。

“扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收 append 函数的返回值。

7.3.1 append添加

package main

import "fmt"

func main() {
   // append()添加元素和切片扩容
   var numSlice []int
   for i := 0; i < 10; i++ {
      numSlice = append(numSlice, i)
      fmt.Printf("%v len:%d cap:%d ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)

   }
}
/*
[0] len:1 cap:1 ptr:0xc0000aa058
[0 1] len:2 cap:2 ptr:0xc0000aa0a0                  
[0 1 2] len:3 cap:4 ptr:0xc0000a8080                
[0 1 2 3] len:4 cap:4 ptr:0xc0000a8080              
[0 1 2 3 4] len:5 cap:8 ptr:0xc0000c40c0            
[0 1 2 3 4 5] len:6 cap:8 ptr:0xc0000c40c0          
[0 1 2 3 4 5 6] len:7 cap:8 ptr:0xc0000c40c0 
*/

7.3.2 append追加多个

package main

import "fmt"

func main() {
   var citySlice []string
   citySlice = append(citySlice, "北京")             // 追加一个元素
   citySlice = append(citySlice, "上海", "广州", "深圳") // 追加多个元素
   fmt.Println(citySlice)                          // [北京 上海 广州 深圳]

   a := []string{"成都", "郑州"}
   citySlice = append(citySlice, a...) // 追加切片

   fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]
}

7.3.3 切片中删除元素

Go 语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。

package main

import "fmt"

func main() {
   a := []int{30, 31, 32, 33, 34, 35, 36, 37}
   a = append(a[:2], a[:3]...) // 要删除索引为 2 的元素
   fmt.Println(a)              //[30 31 33 34 35 36 37]
}

7.3.4 切片合并

package main

import "fmt"

func main() {
   arr1 := []int{2, 7, 1}
   arr2 := []int{5, 9, 3}
   fmt.Println(arr2, arr1)    //[5 9 3] [2 7 1]
   
   arr1 = append(arr1, arr2...)
   fmt.Println(arr1) // [2 7 1 5 9 3]
}