Golang Slice 详解
⚡ 首页 / 📁 后端 / 正文

Golang Slice 详解

# Golang

一、什么是 Slice?

Slice(切片)是 Go 语言中最重要的数据结构之一。日常开发中,数组、集合、数据处理、并发任务队列等场景都会大量使用 Slice。

学习 Slice,重点不是记住 append()、len() 这些函数,而是理解它的底层结构:

  1. Slice 和 Array 有什么区别?
  2. Slice 底层是如何存储数据的?
  3. len 和 cap 分别代表什么?
  4. append 为什么有时候会影响原切片?
  5. 多个 Slice 为什么可能共享底层数组?
  6. Slice 扩容机制是什么?
  7. 如何避免 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 会:

  1. 分配一个新的底层数组。
  2. 将原数组中的元素复制过去。
  3. 将新元素写入新数组。
  4. 返回新的 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
}

必须掌握以下知识:

  1. Slice 是一个包含 Data、Len、Cap 的描述符。
  2. Slice 指向底层数组,而不是数组本身。
  3. 多个 Slice 可以共享底层数组。
  4. append 容量不足时可能重新分配数组。
  5. Slice 赋值不会复制底层数组。
  6. copy 复制元素,但不保证深拷贝。
  7. Slice 并发读写需要同步。
  8. 提前预估容量可以减少内存分配。
  9. 完整切片表达式可以限制子切片容量。
  10. 对包含引用类型的切片进行删除操作时,要注意清理无用引用。

最值得记住的一句话:

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 标准库。


参考资料:

💬 评论交流 0

发表评论

💬 暂无评论,来发表第一条评论吧!