Go 语言中的切片

本位主要介绍一下 Go 语言中可变长度的"数组"——切片(slice)。数组有数组的用处，但是其不可变长度的特性，注定了在大多场景下不是很受欢迎。在大多数场景下我们都会选择更加灵活的切片。

1. 切片的创建

切片的声明方式和数组类似，写法上看就是声明一个没有长度的数组：var 切片名 []切片类型。其中切片类型可以是切片本身，也就是切片的切片，就构成了多维的切片。

切片在使用之前必须要初始化，它没有零值。声明后它的值是 nil，这是因为它的底层实现是一个指向数组的指针，在你给它存入一个数组的地址之前，它只能是 nil。

代码示例：

• 1  package main
• 2
• 3  import (
• 4            "fmt"
• 5  )
• 6
• 7  func main() {
• 8            var a []int
• 9            fmt.Println("初始化前：", a)
• 10          a = make([]int, 5, 10)
• 11          fmt.Println("初始化后：", a)
• 12          a[4] = 5
• 13          fmt.Println(" 赋值后：", a)
• 14          a[5] = 6
• 15          fmt.Println("赋值后：", a)
• 16  }

• 第 8 行：声明一个int类型的切片。
• 第 10 行：声明一个长度为5，切片容量为10的切片。其中容量可以不传，默认会和长度相等。长度为切片真正有值的位置，会初始化零值。
• 第 12 行：给切片的第 5 个位置赋值。
• 第 14 行：给切片的第 6 个位置赋值，但是切片的长度为5，所以会报越界的错误。

执行结果：

2. 切片的截取

切片之所以被叫做切片是有原因的，它可以从任意长度开始切，切到任意长度为止，然后这一段拿出来就是一个新的切片。切割形式为切片名(s)[起始下标(begin):结束下标(end):最大容量(max)]。

Tips：截取到的切片包含起始下标(begin)，不包含结束下标(end)。

切片截取形式表

代码示例：

• 1  package main
• 2
• 3  import (
• 4            "fmt"
• 5  )
• 6
• 7  func main() {
• 8          var a = []int{1, 2, 3, 4, 5}
• 9          fmt.Println("a[1:3]=", a[1:3])
• 10        fmt.Println("a[1:]=", a[1:])
• 11        fmt.Println("a[:3]=", a[:3])
• 12  }

• 第 8 行：直接定义一个值为 [1,2,3,4,5] 的切片，切片长度和容量会根据切片的值自动生成。例如本行代码定义的切片就是长度和容量均为5。
• 第 9 行：取切片下标从1开始到3之前的值，生成新切片。
• 第 10 行：取切片下标从1开始到最后的值，生成新切片。
• 第 11 行：取切片下标从0开始到3的值，生成新切片。

执行结果：

3. 切片的追加

切片使用一个 Go 语言的内置函数append(切片，待添加的值)，来进行切片末尾元素的追加。

代码示例：

• 1  package main
• 2
• 3  import (
• 4          "fmt"
• 5  )
• 6
• 7  func main() {
• 8          var a = []int{1, 2, 3, 4, 5}
• 9          a = append(a, 6)
• 10        fmt.Println(a)
• 11        a = append(a, 7, 8)
• 12        fmt.Println(a)
• 13        b := []int{9, 10}
• 14        a = append(a, b...)
• 15        fmt.Println(a)
• 16  }

• 第 9 行：在切片 a 的末尾追加一个元素 6。
• 第 11 行：在切片 a 的末尾连续追加两个元素 7 和 8。append 中待添加的值可以是 多个，其中使用 , 隔开。
• 第 14 行：在切片 a 的末尾追加切片 b。当 append 中待添加的元素是一个数组或者切片时，在其后面添加 ... 就可以全部追加到切片末尾。

执行结果：

4. 切片的长度和容量

在切片中可以使用len()获取切片中元素的数量，也就是切片的长度。使用cap()可以获取切片引用的数组的长度，也就切片的容量。切片的容量一般大于等于长度，容量会随着长度的增长而增长。

在初始化一个切片的时候其实时给切片引用了一个数组，然后容量就是这个数组的长度，然后如果切片的长度超过了切片的容量，它就会让切片引用一个容量更大数组来存放这些元素。

• 1  package main
• 2
• 3  import (
• 4          "fmt"
• 5  )
• 6
• 7  func main() {
• 8          var a = []int{1, 2, 3, 4, 5}
• 9          fmt.Printf("a的地址%p，a的长度%d，a的容量%dn", a, len(a), cap(a))
• 10        a = append(a, 6)
• 11        fmt.Printf("a的地址%p，a的长度%d，a的容量%dn", a, len(a), cap(a))
• 12        a = append(a, 7, 8)
• 13        fmt.Printf("a的地址%p，a的长度%d，a的容量%dn", a, len(a), cap(a))
• 14        b := []int{9, 10, 11}
• 15        a = append(a, b...)
• 16        fmt.Printf("a的地址%p，a的长度%d，a的容量%dn", a, len(a), cap(a))
• 17  }

执行结果：

从执行结果可以看到，在切片a每次添加的元素要超过它的容量时，它的地址就会发生改变，其实就是让它引用了一个新的容量更大的数组。

5. 小结

本文主要介绍了切片的使用，有以下注意事项：

• 切片在使用前需要初始化；
• 切片的本质是一个指针数组，但是它的地址会随着长度超过容量而改变；
• 在应用场景中一般都使用切片。

文章来源于网络，侵删！