Go 切片

在 Go 语言中,“切片(Slice)” 是一种长度可以动态伸缩的序列。普通的定长数组在定义时就已经把长度写死了,比如 [3]int 永远只能存放 3 个整数,后续既不能往里面添加第 4 个数,也不能缩短长度。

为了打破这种限制,Go 语言提供了更加灵活的切片。从英文意思来看,slice 就是 “切片” 或 “一片” 的意思,我们可以把它看成是从底层数组上切下来的一片 “动态窗口”。在实际开发中,切片的使用频率远远高于数组。

使用字面量定义切片

在 Go 语言中,定义切片的语法和定义数组非常相似。区分两者其实很简单,只要看方括号里有没有写数字就行:定义数组时方括号里必须写明长度或 ...(如 [3]int),而定义切片时方括号里面是空的(如 []int)。

语法:

切片名 := []类型{元素1, 元素2, ..., 元素n}

说明:

方括号加元素类型用来表示切片的数据类型,比如 []int 表示整数切片,[]string 表示字符串切片。花括号 {} 里面是切片的初始元素,各个元素之间使用英文逗号(,)隔开。

在函数内部定义并初始化切片时,我们通常直接使用短变量声明 :=;如果在函数外部定义,则需要使用 var 关键字来声明。

示例 1:定义并初始化切片

package main

import "fmt"

func main() {
    nums := []int{10, 20, 30}
    fruits := []string{"apple", "banana", "orange"}

    fmt.Println(nums)
    fmt.Println(fruits)
    fmt.Printf("nums 的类型:%T\n", nums)
}

运行结果如下。

[10 20 30]
[apple banana orange]
nums 的类型:[]int

分析:

nums := []int{10, 20, 30} 表示定义了一个包含 3 个整数的切片 nums,fruits := []string{"apple", "banana", "orange"} 则定义了一个包含 3 个字符串的切片 fruits。

最后一行通过 fmt.Printf() 的格式符 %T 打印出了 nums 的数据类型。从结果 []int 可以清楚看到,方括号中间没有任何数字,这也是切片最直观的标志。

对于这个例子来说,下面 2 种定义方式是等价的。

// 方式 1(推荐)
nums := []int{10, 20, 30}

// 方式 2
var nums []int = []int{10, 20, 30}

其中,方式 1 使用短变量声明 := 省去了重复的类型书写,写起来干脆利落,因此平时在函数内部我们更推荐使用方式 1。

使用 make() 函数创建切片

除了直接写出初始元素之外,有时我们事先知道切片要存多少个元素,但暂时还不确定每个位置的具体值。这时候,我们可以使用 Go 语言内置的 make() 函数来创建切片。

语法:

切片名 := make([]类型, 长度)

说明:

make() 函数在这里接收两个参数:第 1 个参数是要创建的切片类型(如 []int),第 2 个参数是切片初始包含的元素个数。调用 make() 后,Go 语言会在底层分配好对应数量的空间,并把所有元素自动初始化为该类型的默认零值。

实际上,make() 函数还可以传入第 3 个可选参数来预先指定底层容量,我们会在下一节 “切片长度与容量” 中展开介绍。

示例 2:创建指定长度的切片

package main

import "fmt"

func main() {
    s := make([]int, 4)

    fmt.Println(s)
    fmt.Println(len(s))
}

运行结果如下。

[0 0 0 0]
4

分析:

make([]int, 4) 表示创建了一个初始长度为 4 的整数切片 s。因为创建时没有指定具体数值,这 4 个位置会自动填充 int 类型的默认零值 0,所以第 1 行输出 [0 0 0 0]。

同时,内置函数 len(s) 用来获取切片当前包含的元素个数,因此第 2 行输出 4。如果创建的是字符串切片 make([]string, 4),里面填充的默认零值则会是空字符串 ""。

访问与修改切片元素

切片创建好之后,我们可以通过下标 s[i] 来读取或修改指定位置的元素。切片的下标规则和数组完全一样:第 1 个元素的下标从 0 开始,最后一个元素的下标是 len(s) - 1。下面我们来看一个例子。

示例 3:读取与修改指定元素

package main

import "fmt"

func main() {
    scores := []int{85, 90, 95}

    fmt.Println(scores[0])    // 读取第 1 个元素

    scores[1] = 100           // 修改第 2 个元素的值
    fmt.Println(scores)
}

运行结果如下。

85
[85 100 95]

分析:

scores[0] 表示读取切片 scores 的第 1 个元素,因此输出 85。接着我们执行 scores[1] = 100,把下标为 1(也就是第 2 个位置)的元素从 90 改成 100,再次打印时切片就变成了 [85 100 95]。

注意: 下标 i 不能超出 0 到 len(s) - 1 的范围。对于长度为 0 的切片,千万不要直接写 s[0] = 10 赋值,否则会触发下标越界报错。此时应先使用 make() 分配长度,或调用 append() 追加元素。

nil 切片与空切片

在 Go 语言中,如果我们只使用 var 声明切片变量而不赋初始值,它的默认值就是 nil(表示空值)。这种未初始化的切片叫做 “nil 切片”;而使用空花括号 []int{} 完成初始化的切片,则叫做 “空切片”。

说白了,var s1 []int 就像 “还没准备收纳盒”,底层还没有分配任何空间。而 s2 := []int{} 就像 “已经摆好了一个空收纳盒”,只是里面暂时没放东西。

示例 4:区分 nil 切片与空切片

package main

import "fmt"

func main() {
    var s1 []int
    s2 := []int{}

    fmt.Println(s1, len(s1), s1 == nil)
    fmt.Println(s2, len(s2), s2 == nil)
}

运行结果如下。

[] 0 true
[] 0 false

分析:

从运行结果可以看出,虽然 s1 的默认值是 nil,但 fmt.Println() 依然把 s1 和 s2 都打印成了 [],而且两者的长度 len 都是 0。

不过它们和 nil 比较的结果并不一样:s1 还没有初始化,因此 s1 == nil 返回 true;而 s2 已经完成了初始化,所以 s2 == nil 返回 false。

这里小伙伴们不用去纠结两者的底层差别。平时声明一个待填充的空切片时,直接写 var s []int 就行,后续调用 append() 同样可以直接往里面追加元素。

需要判断切片里有没有元素时,统一写成 if len(s) == 0 就可以了。不管它是 nil 切片还是空切片,这样判断都准确可靠。

切片的引用特性

在 Go 语言中,数组属于 “值类型”。当我们把一个数组赋值给另一个数组时,程序会把里面的所有元素完整复制一份,修改新数组不会影响原数组。

但切片不一样,切片具有 “引用特性”。切片本身并不直接存放元素数据,而是记录了底层数组的位置、长度和容量等信息,就像架在底层数组上方的一个 “窗口”。

当我们把切片 s1 直接赋值给切片 s2 时,两个切片会共用同一个底层数组,结构关系如下图所示。只要通过其中一个切片修改了元素,另一个切片看到的数据也会同步改变。

两个切片共用同一个底层数组

示例 5:多个切片共用底层数组

package main

import "fmt"

func main() {
    s1 := []int{10, 20, 30}
    s2 := s1      // s2 与 s1 共用底层数组
    s2[0] = 50    // 修改 s2 的第 1 个元素

    fmt.Println("s1 =", s1)
    fmt.Println("s2 =", s2)
}

运行结果如下。

s1 = [50 20 30]
s2 = [50 20 30]

分析:

在这个例子中,执行 s2 := s1 后,s2 和 s1 指向了内存中的同一块底层数组。因此当我们执行 s2[0] = 50 修改第 1 个元素时,改动的其实就是那块公共底层数组里的数据,最终 s1 和 s2 都变成了 [50 20 30]。

如果希望复制出一份完全独立、修改后互不影响的新切片,我们可以调用内置的 copy() 函数或标准库的 slices.Clone() 来实现。数组与切片的主要区别如下表所示。

数组与切片的区别
对比项 数组 切片
类型写法 指定长度,如 [3]int 不写长度,如 []int
元素个数 长度固定不变 长度可动态伸缩
直接赋值 复制整份数据,互不影响 共用底层数组,同步变化
相等比较 支持 == 直接比较 仅支持与 nil 比较

平时写 Go 代码时,除非数据个数固定不变且明确需要值拷贝,否则我们一般都直接优先使用切片。

切片的相等比较

可能有些小伙伴会问:“为什么相同类型的数组可以直接使用 == 比较,而两个切片之间却不能呢?”

这是因为切片底层指向的数组可能会动态变化,而且还存在 nil 切片与空切片的差异。为了避免产生歧义,Go 语言禁止直接写 s1 == s2 比较两个切片,否则编译时会直接报错。实际写代码时,我们可以按需求这样处理:

  • 判断是否为空:切片唯一允许的 == 操作就是和 nil 比较(如 s == nil),平时判断切片有没有元素更推荐直接写 len(s) == 0。
  • 判断元素是否相同:从 Go 1.21 开始,标准库内置了专门操作切片的 slices 包。导入 "slices" 包后调用 slices.Equal(s1, s2),即可按顺序逐个对比元素;全部相同返回 true,否则返回 false。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号