Go语言入门11：切片

Keywords: #技术 #Golang #Go 入门笔记
Table of Contents

Go 语言入门基础学习笔记之 Go 语言的切片

golang

切片 Slice

Go 语言切片是对数组的抽象，即引用了一个数组，是一种引用数据类型。

这一点与数组完全不一样，虽然数组类型为 [10]int 而切片类型为 []int，但是它们相差很大，是两个完全不同的数据类型，其中最大的区别就是数组是值类型，而切片是引用数据类型。也就是说，数组在传递进函数中不会被修改，而切片传递进函数后可以被修改。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型，切片（动态数组），与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片

  1. 直接声明一个切片，这时并不会分配空间，还需要 make 函数来创建空间。空切片
var identifier []type

切片不需要说明长度。[]int 就是一个 int 类型切片的数据类型。

  1. 使用 make() 函数来创建切片
var slice1 []type = make([]type, len, cap)
// 或者
slice1 := make([]type, len)

也可以指定容量，其中 capacity 指切片的最大容量，为可选参数，len 是数组的长度并且也是切片的初始长度。元素为被赋值为默认值。

make([]T, length, capacity)

初始化切片

  1. 直接初始化切片
var s = []int{1,2,3}
// 或者
s := []int {1,2,3 }

[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。

  1. 引用数组
s := arr[:]

切片 s 是数组 arr 的引用。

  1. 引用部分数组
s := arr[startIndex:endIndex]

将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。

s := arr[startIndex:]

默认 endIndex 时将表示一直到 arr 的最后一个元素。

s := arr[:endIndex]

默认 startIndex 时将表示从 arr 的第一个元素开始。

  1. 引用另一个切片
s1 := s[startIndex:endIndex]

与引用数组的情况类似。

  1. 通过 make () 函数
s :=make([]int,len,cap)

通过内置函数 make() 初始化切片 s，[]int 标识为其元素类型为 int 的切片。

arr := make([]int, 3, 5) // 切片指向一个int数组，长度为3，容量为5
arr[0], arr[1], arr[2] = 2, 9, 7  // 给切片元素赋值
brr := arr  // 切片的赋值拷贝

在上面这个例子中，需要注意 brr := arr，Go 语言中的所有等号赋值都会发生拷贝，由于切片是一个包含 3 个成员变量的结构体，进行等号拷贝时，实际上拷贝的是那 3 个成员变量，也就是说并没有拷贝底层的数组，而只是拷贝了底层数组的指针。因此 brr 实际上也是指向原来的底层数组。这也就是为什么，当使用 brr[0] = 3 把底层数组的首元素改成了 3，此时使用 arr[0] 访问首元素也变成了 3，他们指向同一个数组。

image.png

这也是由于切片为引用数据类型决定的。因此，同理截取切片中也会发生相同的情况。如果想要拷贝后不互相影响，Go 语言提供了一个 copy 函数，用于完成“深拷贝”， append 和 copy 函数

len 和 cap 函数

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

// 输出结果
len=3 cap=5 slice=[0 0 0]

如果切片不断增加元素，超过了容量大小，系统会自动申请一个更大内存空间，增加容量，一般是原来的两倍大小。这时系统就会将原先的元素数据全部拷贝到新的内存空间，因此不会修改原先的数组元素，也就不会发现上面 arr 和 brr 相会影响的情况了。

image.png

空切片

一个切片在未初始化之前默认为 nil，长度为 0。

package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

// 输出结果
len=0 cap=0 slice=[]
切片是空的

%v 可以打印任何数据类型的详细信息，在这里是把切片中的所有数据打印出来。

var numbers []int 它只声明一个切片，但是没有分配内存空间，并且不能直接给其中一个位置赋值，比如使用 numbers[0] = 1 会报错，这时需要使用 make 来开辟一个空间。

var numbers []int
numbers = make([]int, 3)

这时，会给 numbers 开辟大小为 3 的空间，并给其赋默认值，numbers=[0,0,0]，注意此时的 numbers 并不是空切片，使用 numbers[0] = 1 就可以修改切片的值。

截取切片

可以通过设置下限及上限来设置截取切片。与 python 类似。

package main

import "fmt"

func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

// 输出结果
len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]

append 和 copy 函数

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法。

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

// 输出结果
len=0 cap=0 slice=[]
len=1 cap=1 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=6 slice=[0 1 2 3 4]
len=5 cap=12 slice=[0 1 2 3 4]

append 函数不会修改原始的切片，因为没有传递指针，但是它会返回一个新的操作后的切片。

copy 函数避免了切片的截取和赋值时指向了同一个底层的数组，copy 实现了“深拷贝”，即拷贝了一个副本，开辟了一个新空间。

参考课程：

  1. 8小时转职Golang工程师
  2. Go语言教程 | 菜鸟教程
← prev next →