Go 切片长度与容量

在 Go 语言中,因为切片的长度可以动态伸缩,所以每个切片除了拥有 “长度” 之外,还多了一个非常重要的属性:“容量”。

想要查看这两个属性,我们可以分别使用 Go 语言内置的 len() 函数和 cap() 函数。

获取长度与容量:len() 和 cap()

很多刚接触切片的小伙伴容易把 “长度” 和 “容量” 搞混。其实从英文原意上就很好区分,它们在 Go 语言中分别代表以下 2 个含义:

  • 长度(len):是英文 “length(长度)” 的缩写,表示切片中当前已经存放的元素个数,和获取数组长度的用法完全一样。
  • 容量(cap):是英文 “capacity(容量)” 的缩写,表示在不触发扩容的前提下,底层数组最多可以容纳的元素个数。

我们可以把切片想象成一个 “装水的水杯”:假设水杯最大能装 500 毫升水,目前往里面倒了 300 毫升。那么当前已经装进去的 300 毫升就是切片的 “长度”,而水杯的最大肚量 500 毫升就是切片的 “容量”,两者的关系如下图所示。

切片的长度(len)与容量(cap)

语法:

len(s)
cap(s)

说明:

其中,s 表示目标切片,len(s) 和 cap(s) 的返回值都是 int 类型的整数。

示例 1:查看字面量切片的长度与容量

package main

import "fmt"

func main() {
    ages := []int{18, 20, 22}

    fmt.Println(len(ages))    // 获取切片长度
    fmt.Println(cap(ages))    // 获取切片容量
}

运行结果如下。

3
3

分析:

在这个例子中,我们使用字面量 []int{18, 20, 22} 创建了一个包含 3 个整数的切片 ages。没有单独指定容量时,Go 语言默认分配的底层数组大小刚好等于初始元素个数,因此 len(ages) 和 cap(ages) 的结果都是 3。

使用 make() 指定初始容量

创建切片时,如果只传两个参数写成 make([]int, 4),切片的长度和容量默认是相等的。实际上,make() 函数还支持传入第 3 个参数,用来单独指定切片的初始容量。

语法:

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

说明:

此时 make() 函数接收以下 3 个参数:

  • 切片类型(必选):表示切片的数据类型,例如 []int、[]string。
  • 长度(必选):表示切片初始包含的元素个数,即 len(s) 的初始值。
  • 容量(可选):表示底层数组预先分配的最大元素个数,即 cap(s) 的初始值。如果省略不写,默认容量等于长度。

示例 2:指定不同的初始长度与容量

package main

import "fmt"

func main() {
    s1 := make([]int, 3, 5)
    s2 := make([]int, 0, 5)

    fmt.Println(s1, len(s1), cap(s1))
    fmt.Println(s2, len(s2), cap(s2))
}

运行结果如下。

[0 0 0] 3 5
[] 0 5

分析:

s1 和 s2 的底层容量都是 5,但因为初始长度不同,打印结果和适用场景也有明显区别。

其中,make([]int, 3, 5) 预先分配了能装 5 个整数的空间,并把前 3 个位置初始化为默认零值 0,适合后续直接通过下标 s1[0]、s1[1] 读写元素。

而 make([]int, 0, 5) 同样预留了 5 个整数的空间,但初始长度为 0,切片当前为空 [],非常适合后续从头往里面追加新元素。

平时调用 make() 时,小伙伴们要注意一点:指定的长度不能大于容量。道理很简单,已经装进去的水不可能超过水杯本身的最大肚量。下面这种把长度设成 5、容量设成 3 的写法就是错误的。

s := make([]int, 5, 3)

如果写成上面这样,编译时会直接报错,提示切片的长度不能大于容量。

注意: 通过下标 s[i] 读写元素时,合法范围只看当前长度 len(s),预留容量不能直接访问。比如 make([]int, 3, 5) 的合法下标只有 0~2,直接读写 s1[3] 依然会越界报错。

切片的自动扩容与容量预分配

既然底层数组的大小是由容量决定的,那如果我们继续往切片里放入新元素,超过了当前容量装不下了怎么办呢?其实不用担心,一旦元素个数超过容量,Go 语言会自动在底层申请一块更大的新数组。接着会把旧数据复制过去,再把新元素放进去。

这里我们先借用下一节的 append() 函数向切片末尾追加元素,直观观察一下切片的容量是如何自动增长的。

示例 3:观察切片的自动扩容过程

package main

import "fmt"

func main() {
    s := []int{1, 2}
    fmt.Println("len =", len(s), "cap =", cap(s))

    s = append(s, 3)    // 添加第 3 个元素
    fmt.Println("len =", len(s), "cap =", cap(s))

    s = append(s, 4)    // 添加第 4 个元素
    fmt.Println("len =", len(s), "cap =", cap(s))

    s = append(s, 5)    // 添加第 5 个元素
    fmt.Println("len =", len(s), "cap =", cap(s))
}

运行结果如下。

len = 2 cap = 2
len = 3 cap = 4
len = 4 cap = 4
len = 5 cap = 8

分析:

我们一步步来看看切片 s 的长度和容量是怎么变化的:

  • 初始状态:s := []int{1, 2} 包含 2 个元素,此时长度为 2、容量也为 2,底层空间刚好装满。
  • 添加第 3 个元素:执行 s = append(s, 3) 时,原来的容量 2 装不下 3 个元素了。于是 Go 语言自动在底层换了一块容量翻倍的新数组,此时长度变为 3,容量从 2 涨到了 4。
  • 添加第 4 个元素:执行 s = append(s, 4) 时,上一轮扩容后的容量是 4,还剩一个空闲位置。程序直接把 4 放进预留空间即可,此时长度变为 4,容量保持 4 不变。
  • 添加第 5 个元素:执行 s = append(s, 5) 时,容量 4 又装不下了。底层会再次触发扩容,将容量翻倍为 8,此时长度为 5、容量为 8。

从结果可以看出,当切片较小时,一旦现有容量不够用,Go 语言通常会按原来的 2 倍自动扩容。等元素数量达到几百上千个时,扩容幅度会适当放缓以节省内存,小伙伴们不用去死记具体的扩容公式。

如果我们一开始就大概知道要往切片里放多少个元素,提前使用 make() 把容量留足,追加元素时会是什么效果呢?下面我们再来看一个对比示例。

示例 4:提前预留容量避免频繁扩容

package main

import "fmt"

func main() {
    langs := make([]string, 0, 5)

    langs = append(langs, "C")
    fmt.Println("len =", len(langs), "cap =", cap(langs))

    langs = append(langs, "Go")
    fmt.Println("len =", len(langs), "cap =", cap(langs))

    langs = append(langs, "Python")
    fmt.Println("len =", len(langs), "cap =", cap(langs))
}

运行结果如下。

len = 1 cap = 5
len = 2 cap = 5
len = 3 cap = 5

分析:

在这个例子中,我们一开始就用 make([]string, 0, 5) 为切片 langs 预留了 5 个元素的底层空间。

随后连续追加 3 次数据时,长度 len 从 1 稳步涨到 3,而容量 cap 始终保持在 5。整个过程没有触发一次申请新数组和搬迁数据的操作。

如果事先知道大概需要存多少条数据,比如要存 100 条记录,我们可以直接写 make([]int, 0, 100) 提前留好容量,这样程序运行效率会高出不少。

上一篇:

下一篇:

给站长反馈

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

邮箱:lvyenet@vip.qq.com

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