Go 切片截取

在 Go 语言中,我们可以通过 s[start:end] 截取语法,从一个现有的切片或数组中按范围取出一部分连续的元素,生成一个新的子切片。

切片截取语法

在 Go 语言中,切片截取使用的是方括号加英文冒号 [:] 的形式。截取元素时,最重要的一条规则就是 “左闭右开(含头不含尾)”。

语法:

s[start:end]

说明:

其中,start 和 end 分别代表截取的起始位置和结束位置:

  • start(可选):表示截取的起始下标,结果包含 start 位置的元素。如果省略不写,默认从下标 0(第 1 个元素)开始截取。
  • end(可选):表示截取的结束下标,结果不包含 end 位置的元素,实际只取到下标 end - 1 为止。如果省略不写,默认一直截取到切片末尾 len(s)。

我们可以把 s[start:end] 对应到数学中的左闭右开区间 [start, end):左边的方括号表示包含 start 这一项,右边的圆括号表示不包含 end 这一项。用结束下标减去起始下标 end - start,就能直接算出截取出了几个元素。

平时使用切片截取时,起止下标常规范围应满足 0 <= start <= end <= len(s)。不能写成 start > end,也不能超过切片底层数组的容量范围,否则程序运行时会触发越界报错。常见的切片截取写法如下表所示。

常见切片截取写法
写法 等价形式 说明
s[1:4] s[1:4] 截取下标 1 到 3 的元素
s[:3] s[0:3] 从开头截取前 3 个元素
s[2:] s[2:len(s)] 从下标 2 一直截取到末尾
s[:] s[0:len(s)] 截取全部元素
s[:len(s)-1] s[0:len(s)-1] 截取除最后一项外的元素

注意: 在 Go 语言中,切片的下标和截取位置都不支持负数。我们不能像 Python 那样写 s[-1] 或 s[:-1],否则编译时会直接报错。如果想要去掉末尾的最后一个元素,应该写成 s[:len(s)-1]。

切片截取示例

下面我们通过几个简单的例子,来看看切片截取的具体用法。

示例 1:指定起止下标截取

package main

import "fmt"

func main() {
    nums := []int{10, 20, 30, 40, 50}
    sub := nums[1:4]    // 截取下标 1 到 3 的元素

    fmt.Println(sub)
    fmt.Println(len(sub))
}

运行结果如下。

[20 30 40]
3

分析:

切片 nums 的下标 0 到 4 依次对应 10、20、30、40、50。按 “含头不含尾” 规则,nums[1:4] 从下标 1 截到下标 4 之前,实际取出下标 1、2、3 这 3 项,个数正好等于 4 - 1 = 3。

下面代码中,子切片 sub 最终输出的结果是 [Java Python],小伙伴们可以结合下标位置思考一下为什么。

langs := []string{"Go", "Java", "Python", "C++"}
sub := langs[1:3]
fmt.Println(sub)

示例 2:省略起止下标

package main

import "fmt"

func main() {
    s := []int{10, 20, 30, 40, 50}

    fmt.Println(s[:3])           // 从开头截取前 3 个元素
    fmt.Println(s[2:])           // 从下标 2 截取到末尾
    fmt.Println(s[:len(s)-1])    // 去掉最后一个元素
}

运行结果如下。

[10 20 30]
[30 40 50]
[10 20 30 40]

分析:

当我们从第 1 个元素开始截取或一直截取到末尾时,可以直接省略冒号左边或右边的数字。对于上面这个长度为 5 的切片 s 来说,下面 2 种写法是等价的。

// 方式 1(推荐)
s[:3]
s[2:]

// 方式 2
s[0:3]
s[2:5]

其中,方式 1 省去了默认的起始下标 0 和末尾长度,写起来更加简短,平时我们更推荐使用方式 1。第 3 行输出中的 s[:len(s)-1] 等价于 s[:4],刚好把下标为 4 的最后一个元素 50 排除在外。

除了对切片进行截取之外,[:] 语法同样可以用在定长数组上,把数组快速转换成切片。下面我们来看这个例子。

示例 3:从数组截取生成切片

package main

import "fmt"

func main() {
    colors := [4]string{"red", "green", "blue", "yellow"}
    s1 := colors[1:3]    // 截取下标 1 到 2 的元素
    s2 := colors[:]      // 将整个数组转换为切片

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

运行结果如下。

[green blue]
[red green blue yellow]
s2 的类型:[]string

分析:

在这个例子中,colors 是一个长度为 4 的定长数组 [4]string。执行 s2 := colors[:] 后,我们得到了包含原数组全部元素的切片 s2,它的类型也变成了 []string。

在实际开发中,对数组使用 arr[:] 是把定长数组转换为切片最简便的做法。

子切片的底层内存共享

使用切片截取时,小伙伴们一定要重点掌握一个特性:通过 s[start:end] 截取出来的子切片,并不会在底层复制一份新数据,而是依然和原切片(或原数组)共用同一块底层数组。

同时,因为切片只能向后扩展、不能往前倒退,起点前面的元素已经不在子切片的范围内了。所以子切片的容量 cap 默认是从起始下标 start 开始,一直算到底层数组的末尾,内存共享关系如下图所示。

子切片与原切片共用底层数组及容量范围

示例 4:修改子切片影响原切片

package main

import "fmt"

func main() {
    s := []int{10, 20, 30, 40}
    sub := s[1:3]    // 截取出 [20 30]
    sub[0] = 66      // 修改子切片的第 1 个元素

    fmt.Println("sub =", sub, "len =", len(sub), "cap =", cap(sub))
    fmt.Println("s =", s)
}

运行结果如下。

sub = [66 30] len = 2 cap = 3
s = [10 66 30 40]

分析:

sub := s[1:3] 从原切片 s 中截取出了 [20 30],因此 len(sub) 为 2。而从起始下标 1 到底层数组末尾一共有 3 个位置(即 20、30、40),前面的 10 已经被跳过,所以 cap(sub) 为 3。

由于子切片 sub 和原切片 s 共用同一个底层数组,sub[0] 对应的其实就是原切片里的 s[1]。因此执行 sub[0] = 66 后,原切片 s 里的 20 也同步变成了 66。

不仅直接修改元素会相互影响,当子切片还有剩余容量时,往子切片末尾调用 append() 追加元素同样会改写原切片的数据。下面我们再来看一个例子。

示例 5:未超出容量时向子切片追加元素

package main

import "fmt"

func main() {
    s := []int{10, 20, 30, 40}
    sub := s[1:3]            // len 为 2,cap 为 3
    sub = append(sub, 80)    // 未超出容量,直接写入共用数组

    fmt.Println("sub =", sub)
    fmt.Println("s =", s)
}

运行结果如下。

sub = [20 30 80]
s = [10 20 30 80]

分析:

从运行结果可以看出,向子切片 sub 追加 80 后,原切片 s 末尾的 40 也被改成了 80。这是因为 sub 长度为 2、容量为 3,底层还剩 1 个空位,追加的 80 直接写进了共用底层数组的下一个位置。

那如果往子切片里追加更多元素,超过了它当前的容量 3,结果又会怎么样呢?下面我们通过一个例子验证一下。

示例 6:子切片扩容后不再影响原切片

package main

import "fmt"

func main() {
    s := []int{10, 20, 30, 40}
    sub := s[1:3]                // len 为 2,cap 为 3
    sub = append(sub, 80, 90)    // 超出容量 3,触发扩容搬到新数组
    sub[0] = 66                  // 此时修改不会再影响原切片

    fmt.Println("sub =", sub)
    fmt.Println("s =", s)
}

运行结果如下。

sub = [66 30 80 90]
s = [10 20 30 40]

分析:

对比示例 5 和示例 6 可以清楚看到两者的差别:这次我们一次性向 sub 追加了 80 和 90 两个元素,总长度需要变成 4,超过了原来的容量 3。

于是 Go 语言在底层为 sub 申请了一块全新的数组,把 [20 30] 复制过去后再填入 80 和 90。

扩容搬家之后,sub 和原切片 s 就彻底脱钩了。后面再执行 sub[0] = 66 时,原切片 s 依然保持 [10 20 30 40] 不变。

如果希望从一开始就得到一份完全独立、无论怎么修改或追加都不会影响原切片的新切片,我们直接调用 copy() 函数复制一份独立副本就可以了。

上一篇:

下一篇:

给站长反馈

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

邮箱:lvyenet@vip.qq.com

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