一、什么是 Slice?
Slice(切片)是 Go 语言中最重要的数据结构之一。日常开发中,数组、集合、数据处理、并发任务队列等场景都会大量使用 Slice。
学习 Slice,重点不是记住 append()、len() 这些函数,而是理解它的底层结构:
- Slice 和 Array 有什么区别?
- Slice 底层是如何存储数据的?
len和cap分别代表什么?append为什么有时候会影响原切片?- 多个 Slice 为什么可能共享底层数组?
- Slice 扩容机制是什么?
- 如何避免 Slice 的内存泄漏和并发问题?
本文从基础用法开始,逐步深入 Slice 的底层实现。
二、Slice 基础
2.1 Slice 和 Array 的区别
数组(Array):
var arr [3]int = [3]int{10, 20, 30}
fmt.Println(arr)
数组长度是类型的一部分,[3]int 和 [4]int 是不同的类型。
切片(Slice):
var nums []int = []int{10, 20, 30}
fmt.Println(nums)
切片长度可以动态变化:
nums = append(nums, 40)
nums = append(nums, 50)
fmt.Println(nums) // [10 20 30 40 50]
两者的区别:
| 特性 | Array | Slice |
|---|---|---|
| 长度 | 固定 | 动态变化 |
| 是否可以扩容 | 不可以 | 可以 |
| 是否有底层数组 | 自身就是数组 | 引用底层数组 |
| 是否可以直接比较 | 可以(元素可比较时) | 只能与 nil 比较 |
| 使用频率 | 较低 | 非常高 |
2.2 Slice 的声明方式
方式一:直接声明
var nums []int
fmt.Println(nums) // []
fmt.Println(len(nums)) // 0
fmt.Println(cap(nums)) // 0
fmt.Println(nums == nil) // true
此时切片是 nil,没有底层数组。
方式二:使用字面量
nums := []int{10, 20, 30}
方式三:使用 make
nums := make([]int, 3)
fmt.Println(nums) // [0 0 0]
指定长度和容量:
nums := make([]int, 3, 5)
fmt.Println(len(nums)) // 3
fmt.Println(cap(nums)) // 5
这里需要理解两个概念:
len:当前切片包含多少个元素。cap:从当前切片起始位置到底层数组末尾,最多可以容纳多少个元素。
2.3 nil Slice 和 Empty Slice
这两个概念容易混淆。
var a []int
b := []int{}
c := make([]int, 0)
fmt.Println(a == nil) // true
fmt.Println(b == nil) // false
fmt.Println(c == nil) // false
三者的长度和容量都是 0,但 nil 状态不同。
实际开发中:
var a []int:适合表示尚未初始化的数据集合。[]int{}:适合明确表示一个空集合。make([]int, 0):适合需要提前构造空切片的场景。
JSON 序列化时,它们也会产生不同结果:
var a []int
b := []int{}
data1, _ := json.Marshal(a)
data2, _ := json.Marshal(b)
fmt.Println(string(data1)) // null
fmt.Println(string(data2)) // []
因此,在 API 开发中,需要注意 nil Slice 和空 Slice 的区别。
三、Slice 底层数据结构
这是理解 Slice 的核心。
3.1 Slice 的底层结构
Slice 本身不是数组,而是一个描述底层数组的结构体。
其核心结构可以理解为:
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
三个字段:
| 字段 | 作用 |
|---|---|
| Data | 底层数组数据的起始地址 |
| Len | 当前切片长度 |
| Cap | 当前切片容量 |
注意:这是帮助理解的结构示意,不建议使用 reflect.SliceHeader 操作实际内存。Go 内部运行时的真实实现及其细节以对应版本源码为准。
3.2 Slice 内存结构
假设:
nums := make([]int, 3, 5)
nums[0] = 10
nums[1] = 20
nums[2] = 30
底层数组有 5 个位置:
底层数组(Capacity = 5)
+------+------+------+------+------+
| 10 | 20 | 30 | 0 | 0 |
+------+------+------+------+------+
0 1 2 3 4
+------------------+
| 当前 Slice 范围 |
+------------------+
Len = 3
Cap = 5
虽然底层数组有 5 个元素空间,但当前切片只能通过下标访问:
nums[0]
nums[1]
nums[2]
下面的代码会发生越界:
fmt.Println(nums[3]) // panic
因为下标访问受 len 限制,而不是 cap。
但是可以通过扩展切片访问:
nums = nums[:5]
fmt.Println(nums) // [10 20 30 0 0]
3.3 Slice 为什么可以共享底层数组?
看下面的代码:
nums := []int{10, 20, 30, 40, 50}
s1 := nums[1:4]
fmt.Println(s1) // [20 30 40]
s1 并没有创建一个全新的数组,而是引用了原来的底层数组。
内存关系:
原切片 nums
+------+------+------+------+------+
| 10 | 20 | 30 | 40 | 50 |
+------+------+------+------+------+
0 1 2 3 4
新切片 s1 = nums[1:4]
+------+------+------+
| 20 | 30 | 40 |
+------+------+------+
0 1 2
验证:
nums := []int{10, 20, 30, 40, 50}
s1 := nums[1:4]
s1[0] = 999
fmt.Println(nums)
// [10 999 30 40 50]
为什么原切片也发生变化?
因为两个切片操作的是同一块底层内存。
这是 Slice 最重要的特性之一。
四、len 和 cap 深入理解
4.1 len 和 cap 的区别
看一个例子:
nums := []int{10, 20, 30, 40, 50}
s1 := nums[1:3]
fmt.Println(len(s1)) // 2
fmt.Println(cap(s1)) // 4
为什么容量是 4?
因为 s1 从原数组的下标 1 开始,到底层数组末尾还有 4 个位置。
计算公式:
len(s1) = 3 - 1 = 2
cap(s1) = 5 - 1 = 4
记住:
len = 当前切片可以直接访问的元素数量
cap = 从当前切片起始位置开始,底层数组剩余的容量
4.2 切片扩展
nums := []int{10, 20, 30, 40, 50}
s1 := nums[1:3]
fmt.Println(s1) // [20 30]
s1 = s1[:4]
fmt.Println(s1) // [20 30 40 50]
为什么可以从长度 2 扩展到长度 4?
因为 s1 的容量是 4。
但是:
s1 = s1[:5]
会发生 panic,因为超过了容量。
4.3 完整切片表达式
Go 还提供了一种特殊的切片方式:
s := nums[low:high:max]
它可以主动限制新切片的容量。
例如:
nums := []int{10, 20, 30, 40, 50}
s1 := nums[1:3:3]
fmt.Println(s1) // [20 30]
fmt.Println(len(s1)) // 2
fmt.Println(cap(s1)) // 2
计算公式:
len = high - low
cap = max - low
这个功能有什么用?
避免子切片通过 append 意外覆盖原切片后续的数据。
例如:
nums := []int{10, 20, 30, 40, 50}
s1 := nums[1:3:3]
s1 = append(s1, 999)
fmt.Println(nums)
// [10 20 30 40 50]
fmt.Println(s1)
// [20 30 999]
由于 s1 的容量只有 2,追加元素时需要重新分配底层数组,因此不会修改原数组中的 40。
这是一个非常实用的技巧。
五、append 扩容机制
这是 Go Slice 最容易产生误解的地方。
5.1 append 的基本用法
nums := []int{10, 20, 30}
nums = append(nums, 40)
fmt.Println(nums)
// [10 20 30 40]
注意:
append() 会返回一个新的 Slice 描述符,因此必须接收返回值。
错误写法:
append(nums, 40)
正确写法:
nums = append(nums, 40)
5.2 append 什么时候会修改原数组?
先看:
nums := make([]int, 2, 5)
nums[0] = 10
nums[1] = 20
s1 := nums
s1 = append(s1, 30)
fmt.Println(nums) // [10 20]
fmt.Println(s1) // [10 20 30]
这里看起来 nums 没有变化。
但实际上,底层数组已经被修改了。
fmt.Println(nums[:3])
// [10 20 30]
为什么?
因为原切片容量为 5,追加元素时还有剩余空间,不需要重新分配底层数组。
两个切片仍然指向同一块内存。
内存变化:
append 前:
+------+------+------+------+------+
| 10 | 20 | 空 | 空 | 空 |
+------+------+------+------+------+
len = 2
cap = 5
append(s1, 30) 后:
+------+------+------+------+------+
| 10 | 20 | 30 | 空 | 空 |
+------+------+------+------+------+
nums 的 len 仍然是 2
s1 的 len 变成 3
但底层数组仍然共享。
5.3 append 什么时候会分配新数组?
nums := make([]int, 2, 2)
nums[0] = 10
nums[1] = 20
s1 := append(nums, 30)
fmt.Println(nums) // [10 20]
fmt.Println(s1) // [10 20 30]
因为原切片容量已经用完。
Go 会:
- 分配一个新的底层数组。
- 将原数组中的元素复制过去。
- 将新元素写入新数组。
- 返回新的 Slice 描述符。
此时:
nums ──> 原底层数组 [10, 20]
s1 ──> 新底层数组 [10, 20, 30]
两个切片不再共享底层数组。
5.4 Go 的扩容机制
当 append 导致容量不足时,Go 运行时会进行扩容。
需要注意:Go 的扩容策略不是一个固定的、所有版本都不变的倍数规则。
在常见的 Go 实现中:
- 小容量切片扩容通常增长较快。
- 大容量切片增长会逐渐趋缓。
- 内存分配器还会根据元素大小、内存规格等因素调整实际分配容量。
可以通过代码观察:
package main
import "fmt"
func main() {
nums := make([]int, 0)
for i := 0; i < 20; i++ {
oldCap := cap(nums)
nums = append(nums, i)
if oldCap != cap(nums) {
fmt.Printf(
"len=%d, oldCap=%d, newCap=%d\n",
len(nums),
oldCap,
cap(nums),
)
}
}
}
建议实际运行观察扩容过程。
工程建议: 如果提前知道切片大概需要存储多少数据,尽量提前指定容量。
不推荐:
var users []User
for i := 0; i < 10000; i++ {
users = append(users, User{})
}
推荐:
users := make([]User, 0, 10000)
for i := 0; i < 10000; i++ {
users = append(users, User{})
}
这样可以减少扩容次数和内存分配。
六、copy 深入理解
copy() 用于将一个切片中的元素复制到另一个切片。
6.1 基本用法
src := []int{10, 20, 30}
dst := make([]int, len(src))
n := copy(dst, src)
fmt.Println(dst) // [10 20 30]
fmt.Println(n) // 3
copy() 返回实际复制的元素数量。
6.2 copy 和直接赋值的区别
这是一个非常重要的知识点。
直接赋值:
a := []int{10, 20, 30}
b := a
b[0] = 999
fmt.Println(a) // [999 20 30]
fmt.Println(b) // [999 20 30]
因为两个切片共享底层数组。
使用 copy:
a := []int{10, 20, 30}
b := make([]int, len(a))
copy(b, a)
b[0] = 999
fmt.Println(a) // [10 20 30]
fmt.Println(b) // [999 20 30]
现在两个切片拥有不同的底层数组。
| 操作 | 是否复制元素 | 是否共享底层数组 |
|---|---|---|
b := a |
否 | 是 |
b := a[1:3] |
否 | 是 |
copy(b, a) |
是 | 否(前提是目标数组独立) |
注意:copy 是浅拷贝。如果 Slice 的元素是指针、Map 或包含引用类型的结构体,内部引用仍然可能共享。
例如:
type User struct {
Name string
Tags []string
}
复制 []User 后,Tags 对应的底层数组仍可能共享。
七、Slice 常用操作
Go 的 Slice 没有内置的 remove()、insert() 方法,通常通过 append 和 copy 实现。
7.1 添加元素
nums := []int{1, 2, 3}
nums = append(nums, 4)
7.2 添加多个元素
a := []int{1, 2, 3}
b := []int{4, 5, 6}
a = append(a, b...)
... 表示将切片展开为多个参数。
结果:
[1 2 3 4 5 6]
7.3 删除指定下标元素
例如删除下标 1:
nums := []int{10, 20, 30, 40}
index := 1
nums = append(nums[:index], nums[index+1:]...)
fmt.Println(nums)
// [10 30 40]
原理:
原切片:[10 20 30 40]
nums[:1] = [10]
nums[2:] = [30 40]
合并后:[10 30 40]
对于包含指针或其他引用类型的元素,建议清理尾部被删除的引用,避免底层数组继续持有对象。
例如:
copy(nums[index:], nums[index+1:])
nums[len(nums)-1] = 0
nums = nums[:len(nums)-1]
这里假设元素类型是 int。
7.4 插入元素
在下标 1 插入 999:
nums := []int{10, 20, 30}
index := 1
value := 999
nums = append(nums, 0)
copy(nums[index+1:], nums[index:])
nums[index] = value
fmt.Println(nums)
// [10 999 20 30]
7.5 遍历切片
普通 for 循环:
nums := []int{10, 20, 30}
for i := 0; i < len(nums); i++ {
fmt.Println(nums[i])
}
for range:
for index, value := range nums {
fmt.Println(index, value)
}
注意:range 的 value 是元素值的副本。
nums := []int{10, 20, 30}
for _, value := range nums {
value = 999
}
fmt.Println(nums)
// [10 20 30]
如果需要修改原切片:
for i := range nums {
nums[i] = 999
}
八、Slice 的高级知识与常见陷阱
8.1 删除元素导致内存无法释放
看这个例子:
data := make([]int, 1000000)
data = data[:10]
虽然现在 len(data) == 10,但它仍然可能引用原来包含 100 万个元素的底层数组。
如果这个切片长期存在,就可能造成不必要的内存占用。
解决方式:
data = append([]int(nil), data...)
这会复制当前有效元素到新的底层数组。
对于较大的切片,可以通过性能测试确认是否值得这样处理。
8.2 Slice 不能直接比较
下面的代码会编译失败:
a := []int{1, 2, 3}
b := []int{1, 2, 3}
fmt.Println(a == b) // 编译错误
Slice 只能与 nil 进行直接比较。
Go 1.21 及以上版本可以使用:
import "slices"
fmt.Println(slices.Equal(a, b)) // true
8.3 Slice 不是线程安全的
例如:
var nums []int
go func() {
nums = append(nums, 1)
}()
go func() {
nums = append(nums, 2)
}()
多个 Goroutine 同时修改同一个 Slice,可能产生数据竞争。
可以使用 Mutex:
var (
nums []int
mu sync.Mutex
)
func add(value int) {
mu.Lock()
defer mu.Unlock()
nums = append(nums, value)
}
注意:如果其他 Goroutine 同时读取 nums,也需要同步保护。
可以使用下面的命令检测数据竞争:
go run -race main.go
8.4 range 遍历时修改切片
例如:
nums := []int{1, 2, 3, 4, 5}
for i, v := range nums {
if v == 3 {
nums = append(nums[:i], nums[i+1:]...)
}
}
fmt.Println(nums)
这种写法容易出现逻辑错误。
原因是 range 会按照开始遍历时确定的切片长度进行迭代,而你又修改了切片内容和长度。
如果需要边遍历边删除,通常采用从后往前遍历:
for i := len(nums) - 1; i >= 0; i-- {
if nums[i] == 3 {
nums = append(nums[:i], nums[i+1:]...)
}
}
九、Go 1.21+ slices 标准库
Go 1.21 开始,标准库提供了 slices 包,包含大量切片操作函数。
import "slices"
常用函数:
| 函数 | 作用 |
|---|---|
slices.Contains(s, v) |
判断是否包含元素 |
slices.Index(s, v) |
查找元素下标 |
slices.Clone(s) |
克隆切片 |
slices.Equal(a, b) |
判断两个切片是否相等 |
slices.Reverse(s) |
反转切片 |
slices.Sort(s) |
排序 |
slices.Delete(s, i, j) |
删除指定范围 |
slices.Insert(s, i, v...) |
指定位置插入 |
slices.Replace(s, i, j, v...) |
替换指定范围 |
slices.Compact(s) |
删除连续重复元素 |
示例:
package main
import (
"fmt"
"slices"
)
func main() {
nums := []int{5, 3, 1, 4, 2}
// 排序
slices.Sort(nums)
fmt.Println(nums) // [1 2 3 4 5]
// 判断是否包含
fmt.Println(slices.Contains(nums, 3)) // true
// 查找下标
fmt.Println(slices.Index(nums, 3)) // 2
// 反转
slices.Reverse(nums)
fmt.Println(nums) // [5 4 3 2 1]
// 克隆
cloned := slices.Clone(nums)
// 删除元素
cloned = slices.Delete(cloned, 0, 2)
fmt.Println(cloned) // [3 2 1]
}
实际项目中,建议优先使用标准库 slices,减少重复编写工具函数。
十、Slice 知识体系总结
Slice 的核心结构可以概括为:
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
必须掌握以下知识:
- Slice 是一个包含 Data、Len、Cap 的描述符。
- Slice 指向底层数组,而不是数组本身。
- 多个 Slice 可以共享底层数组。
- append 容量不足时可能重新分配数组。
- Slice 赋值不会复制底层数组。
- copy 复制元素,但不保证深拷贝。
- Slice 并发读写需要同步。
- 提前预估容量可以减少内存分配。
- 完整切片表达式可以限制子切片容量。
- 对包含引用类型的切片进行删除操作时,要注意清理无用引用。
最值得记住的一句话:
Slice 是一个包含 Data、Len、Cap 的描述符,它指向底层数组,而不是数组本身。
只要理解这句话,Slice 的大部分行为就能解释清楚。
十一、实战练习
建议按照以下顺序动手完成。
练习一:基础操作
创建一个长度为 3、容量为 5 的 int 切片,添加两个元素,并打印 len 和 cap。
提示:使用 make 和 append。
练习二:底层数组共享
创建:
nums := []int{10, 20, 30, 40, 50}
截取 nums[1:3],修改新切片第一个元素,观察原切片变化。
提示:重点理解共享底层数组。
练习三:append 扩容
分别创建:
a := make([]int, 2, 5)
b := make([]int, 2, 2)
分别追加一个元素,比较原切片和追加后切片的结果。
提示:通过扩展原切片长度观察底层数组。
练习四:实现删除函数
编写 Remove 函数,传入一个 []int 和下标,返回删除元素后的切片。
提示:使用 copy 或 append。
练习五:用户数据处理
定义 User 结构体,创建用户切片,实现:
- 添加用户。
- 删除用户。
- 根据 ID 查找用户。
- 按年龄排序。
提示:结合 struct、Slice、for range 和 slices 标准库。
参考资料:
💬 暂无评论,来发表第一条评论吧!