在 Go 语言中,因为切片的长度可以动态伸缩,所以每个切片除了拥有 “长度” 之外,还多了一个非常重要的属性:“容量”。
想要查看这两个属性,我们可以分别使用 Go 语言内置的 len() 函数和 cap() 函数。
获取长度与容量:len() 和 cap()
很多刚接触切片的小伙伴容易把 “长度” 和 “容量” 搞混。其实从英文原意上就很好区分,它们在 Go 语言中分别代表以下 2 个含义:
- 长度(len):是英文 “length(长度)” 的缩写,表示切片中当前已经存放的元素个数,和获取数组长度的用法完全一样。
- 容量(cap):是英文 “capacity(容量)” 的缩写,表示在不触发扩容的前提下,底层数组最多可以容纳的元素个数。
我们可以把切片想象成一个 “装水的水杯”:假设水杯最大能装 500 毫升水,目前往里面倒了 300 毫升。那么当前已经装进去的 300 毫升就是切片的 “长度”,而水杯的最大肚量 500 毫升就是切片的 “容量”,两者的关系如下图所示。

语法:
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) 提前留好容量,这样程序运行效率会高出不少。
