【Go语言学习系列06】Go基础语法（四）：数组与切片

📚 原创系列： “Go语言学习系列”

🔄 转载说明： 本文最初发布于"Gopher部落"微信公众号，经原作者授权转载。

🔗 关注原创： 欢迎扫描文末二维码，关注"Gopher部落"微信公众号获取第一手Go技术文章。

📑 Go语言学习系列导航

本文是【Go语言学习系列】的第6篇，当前位于第一阶段（入门篇）

🚀 第一阶段：入门篇

1. Go语言简介与环境搭建
2. Go开发工具链介绍
3. Go基础语法（一）：变量与数据类型
4. Go基础语法（二）：流程控制
5. Go基础语法（三）：函数
6. Go基础语法（四）：数组与切片 👈 当前位置
7. Go基础语法（五）：映射
8. Go基础语法（六）：结构体
9. Go基础语法（七）：指针
10. Go基础语法（八）：接口
11. 错误处理与异常
12. 第一阶段项目实战：命令行工具

📚 查看完整Go语言学习系列导航

📖 文章导读

在本文中，您将学习：

• 数组与切片的本质区别与各自适用场景
• 数组的声明、初始化与内存布局特性
• 切片的工作原理、扩容机制与内存优化
• 多维数组与切片的创建与访问技巧
• 基于Go 1.22的最新切片操作和优化方法
• 实战项目中数组与切片的常见陷阱与最佳实践

数组和切片是Go语言中最基础也最常用的数据结构，正确理解和使用它们对于编写高效的Go程序至关重要。本文将从底层原理到实际应用，帮助您全面掌握这两种核心数据类型。

---

Go基础语法（四）：数组与切片深度剖析

数组和切片是Go语言中最常用的数据结构，用于存储同类型元素的集合。虽然它们在使用上有相似之处，但在内部实现和行为特性上有着本质区别。本文将深入剖析这两种数据结构的底层原理和使用方法，帮助你在实际开发中做出正确的选择和优化。

一、数组基础

1.1 数组的特性与定义

在Go中，数组是具有固定长度的同类型元素序列，长度是数组类型的一部分。这意味着[5]int和[10]int是两种不同的类型。

定义数组的几种方式：

// 方式1：声明时指定长度，元素自动初始化为零值
var arr1 [5]int

// 方式2：声明时初始化
var arr2 [3]string = [3]string{"Go", "语言", "学习"}

// 方式3：使用短变量声明，编译器自动计算长度
arr3 := [...]int{1, 2, 3, 4} // 长度为4

// 方式4：指定索引位置初始化
arr4 := [5]int{0: 10, 2: 30, 4: 50} // [10, 0, 30, 0, 50]

数组的关键特性：

• 长度固定，创建后不可改变
• 长度是类型的一部分
• 在函数间传递数组时是值传递，会复制整个数组
• 数组在内存中是连续存储的

1.2 数组操作与访问

数组元素通过索引访问，索引从0开始：

arr := [5]int{10, 20, 30, 40, 50}

// 访问元素
fmt.Println(arr[0]) // 10
fmt.Println(arr[4]) // 50

// 修改元素
arr[1] = 25
fmt.Println(arr) // [10 25 30 40 50]

// 获取数组长度
fmt.Println(len(arr)) // 5

注意事项：

• 索引越界会导致运行时错误（panic）
• 不能使用append函数向数组添加元素
• 数组比较使用==运算符（内容相同即相等）

1.3 数组的内存布局

数组在内存中是连续存储的，这使得访问元素非常高效：

arr := [5]int{10, 20, 30, 40, 50}
fmt.Printf("数组第一个元素的内存地址：%p\n", &arr[0])
fmt.Printf("数组第二个元素的内存地址：%p\n", &arr[1])

输出（地址值可能不同，但差值为int大小，通常为8字节）：

数组第一个元素的内存地址：0xc0000140f0
数组第二个元素的内存地址：0xc0000140f8

在64位系统上，连续元素的内存地址差8个字节，正好是int类型的大小。

1.4 数组作为函数参数

重要：Go中数组是值类型，作为函数参数时会复制整个数组：

func modifyArray(arr [5]int) {
    arr[0] = 100
    fmt.Println("函数内数组:", arr) // [100 20 30 40 50]
}

func main() {
    arr := [5]int{10, 20, 30, 40, 50}
    modifyArray(arr)
    fmt.Println("函数外数组:", arr) // [10 20 30 40 50]，未被修改
}

如果要在函数中修改原数组，需要使用数组指针：

func modifyArrayWithPointer(arr *[5]int) {
    arr[0] = 100
    fmt.Println("函数内数组:", *arr) // [100 20 30 40 50]
}

func main() {
    arr := [5]int{10, 20, 30, 40, 50}
    modifyArrayWithPointer(&arr)
    fmt.Println("函数外数组:", arr) // [100 20 30 40 50]，被修改
}

二、切片（Slice）详解

2.1 切片的本质与特性

切片是对数组的抽象和封装，提供了更灵活的操作序列元素的方式。切片本身不存储任何数据，它只是底层数组的一个引用。

切片的内部结构包含三个部分：

• 指向底层数组的指针
• 切片的长度（len）
• 切片的容量（cap）

创建切片的多种方式：

// 方式1：使用make函数
slice1 := make([]int, 5)       // 长度和容量都是5
slice2 := make([]int, 3, 10)   // 长度为3，容量为10

// 方式2：切片字面量
slice3 := []int{1, 2, 3, 4, 5} // 注意，没有...

// 方式3：从数组创建切片
arr := [5]int{10, 20, 30, 40, 50}
slice4 := arr[1:4]  // [20 30 40]，从索引1到3

// 方式4：从已有切片创建新切片
slice5 := slice4[1:] // [30 40]，从索引1到末尾

切片的重要特性：

• 长度可变，但底层依赖数组
• 多个切片可以共享同一个底层数组
• 传递切片是引用传递，非常高效
• 切片的零值是nil，长度和容量都为0

2.2 切片的长度与容量

理解切片的长度与容量是掌握切片的关键：

slice := make([]int, 3, 10)
fmt.Println(len(slice)) // 3，可以直接访问的元素数量
fmt.Println(cap(slice)) // 10，底层数组的大小

// 添加元素，不会导致扩容
slice = append(slice, 1, 2)
fmt.Println(len(slice)) // 5
fmt.Println(cap(slice)) // 10

// 继续添加元素，直到超过容量
for i := 0; i < 6; i++ {
    slice = append(slice, i)
}
fmt.Println(len(slice)) // 11
fmt.Println(cap(slice)) // 20，自动扩容至原来的2倍

重要概念：

• 长度（len）：切片中当前元素的数量，可通过len()函数获取
• 容量（cap）：从切片第一个元素开始，到底层数组末尾的元素数量，可通过cap()函数获取
• 当添加元素导致长度超过容量时，Go会自动扩容，创建一个更大的底层数组，并复制数据

2.3 切片的扩容机制

了解Go切片的扩容规则有助于编写更高效的代码。以下是Go 1.18后的扩容规则（Go 1.22未改变这一机制）：

1. 如果新容量大于当前容量的两倍，则直接使用新容量
2. 如果当前容量小于256，则新容量为当前容量的2倍
3. 如果当前容量大于或等于256，则新容量 = 当前容量 + (当前容量 / 4)，即增加25%
4. 计算出的容量会被舍入到较大的值以对齐内存

实际扩容例子：

s := make([]int, 0)
capValues := []int{}

// 观察扩容过程
for i := 0; i < 2000; i++ {
    s = append(s, i)
    currentCap := cap(s)
    
    // 记录每次容量变化
    if len(capValues) == 0 || capValues[len(capValues)-1] != currentCap {
        capValues = append(capValues, currentCap)
    }
}

fmt.Println("容量变化序列:", capValues)
// 输出类似：[1 2 4 8 16 32 64 128 256 320 400 504 632 792 992 1240 1552 1940 2432]

扩容需要创建新数组并复制数据，这是一个较为昂贵的操作。因此，如果预知切片可能增长到的大小，最好使用make函数预分配足够的容量。

2.4 切片的常用操作

添加元素（append）

slice := []int{1, 2, 3}
slice = append(slice, 4)        // 添加单个元素
slice = append(slice, 5, 6, 7)  // 添加多个元素
another := []int{8, 9, 10}
slice = append(slice, another...) // 添加另一个切片
fmt.Println(slice) // [1 2 3 4 5 6 7 8 9 10]

切片操作

original := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

// 基本切片操作：slice[low:high]
slice1 := original[2:5]  // [2 3 4]，索引2到4

// 省略low或high
slice2 := original[:3]   // [0 1 2]，从开始到索引2
slice3 := original[7:]   // [7 8 9]，从索引7到末尾

// 完整表达式：slice[low:high:max]，限制容量
slice4 := original[2:5:7] // len=3, cap=5 (7-2)

复制切片（copy）

src := []int{1, 2, 3, 4, 5}
dest := make([]int, len(src))
copied := copy(dest, src) // 返回复制的元素数
fmt.Println(dest)         // [1 2 3 4 5]
fmt.Println(copied)       // 5

// 复制部分元素
dest2 := make([]int, 3)
copied2 := copy(dest2, src) 
fmt.Println(dest2)        // [1 2 3]
fmt.Println(copied2)      // 3

删除元素

Go没有内置的切片删除函数，但可以通过拼接实现：

// 从切片中删除索引为2的元素
slice := []int{1, 2, 3, 4, 5}
slice = append(slice[:2], slice[3:]...)
fmt.Println(slice) // [1 2 4 5]

清空切片

slice := []int{1, 2, 3, 4, 5}
// 方法1：保留底层数组
slice = slice[:0]

// 方法2：完全清空，允许垃圾回收底层数组
slice = nil

2.5 切片的内存共享

多个切片可以共享同一个底层数组，这是一个强大的特性，但也可能导致意外的行为：

original := []int{1, 2, 3, 4, 5}
slice1 := original[1:3]   // [2 3]
slice2 := original[2:4]   // [3 4]

// 修改slice1会影响original和slice2
slice1[1] = 99
fmt.Println(original)     // [1 2 99 4 5]
fmt.Println(slice2)       // [99 4]

避免共享带来的意外修改，可以使用copy函数创建独立副本：

original := []int{1, 2, 3, 4, 5}
slice := original[1:3]
sliceCopy := make([]int, len(slice))
copy(sliceCopy, slice)

// 修改sliceCopy不会影响original
sliceCopy[0] = 99
fmt.Println(original)     // [1 2 3 4 5]，未被修改
fmt.Println(sliceCopy)    // [99 3]

三、多维数组与切片

3.1 多维数组

多维数组在声明时需要指定每个维度的大小：

// 2x3的二维数组
var matrix [2][3]int = [2][3]int{
    {1, 2, 3},
    {4, 5, 6},
}

// 访问元素
fmt.Println(matrix[0][1]) // 2
fmt.Println(matrix[1][2]) // 6

// 修改元素
matrix[0][0] = 10
fmt.Println(matrix) // [[10 2 3] [4 5 6]]

3.2 多维切片

多维切片比多维数组更灵活，因为每个维度的长度可以不同：

// 创建二维切片
matrix := make([][]int, 3)
for i := range matrix {
    matrix[i] = make([]int, i+1)
    for j := range matrix[i] {
        matrix[i][j] = i + j
    }
}

fmt.Println(matrix) // [[0] [1 2] [2 3 4]]

// 使用字面量
jaggedMatrix := [][]int{
    {1, 2},
    {3, 4, 5},
    {6},
}

多维切片在内存中不是连续存储的，每个内部切片都有自己的底层数组。

四、性能优化与实践技巧

4.1 预分配内存

合理预分配可以显著提高性能，避免频繁扩容：

// 不推荐：频繁扩容
badFunc := func() []int {
    var s []int
    for i := 0; i < 10000; i++ {
        s = append(s, i)
    }
    return s
}

// 推荐：预分配足够空间
goodFunc := func() []int {
    s := make([]int, 0, 10000)
    for i := 0; i < 10000; i++ {
        s = append(s, i)
    }
    return s
}

基准测试显示，预分配内存的方式可以提高2-3倍的性能，并减少内存分配次数。

4.2 使用copy而非re-slice

当需要截取切片的一部分，但不希望保留对原底层数组的引用时，使用copy而非简单的re-slice：

// 不推荐：保留了对大数组的引用
data := loadLargeData() // 假设加载了100MB的数据
// firstPart引用了整个大数组，阻止垃圾回收
firstPart := data[:100] 

// 推荐：创建独立副本
firstPartCopy := make([]byte, 100)
copy(firstPartCopy, data[:100])
data = nil // 允许大数组被垃圾回收

4.3 谨慎处理大切片

处理大量数据时，尤其要注意内存使用：

func processData(data []byte) []byte {
    // 如果只需要数据的一小部分，最好复制而非引用
    if len(data) > 1024*1024 {
        relevant := make([]byte, 1024)
        copy(relevant, data[:1024])
        return processSmallData(relevant)
    }
    return processSmallData(data)
}

4.4 切片的容量控制

使用三索引切片表达式控制切片的容量，防止意外共享和扩容：

original := make([]int, 0, 10)
for i := 0; i < 5; i++ {
    original = append(original, i)
}

// 限制容量等于长度，防止共享
limited := original[:3:3] // 长度=3，容量=3
limited = append(limited, 100) // 这会创建新的底层数组

// 现在修改limited不会影响original
fmt.Println(original) // [0 1 2 3 4]
fmt.Println(limited)  // [0 1 2 100]

4.5 Go 1.22新特性

Go 1.22（2024年2月发布）引入了几个与切片相关的新功能：

// 1. 切片的clear函数 - 将切片元素重置为零值
s := []int{1, 2, 3, 4, 5}
clear(s)  // Go 1.22新特性
fmt.Println(s) // [0 0 0 0 0]

// 2. 直接对整数使用range
// 在Go 1.22之前需要先创建切片
for i := range 5 {
    fmt.Println(i) // 输出0,1,2,3,4
}

// 3. max/min等通用函数可用于切片
nums := []int{3, 1, 5, 2, 4}
maxVal := slices.Max(nums)  // 需要导入 golang.org/x/exp/slices
fmt.Println(maxVal) // 5

👨‍💻 关于作者与Gopher部落

"Gopher部落"专注于Go语言技术分享，提供从入门到精通的完整学习路线。

🌟 为什么关注我们？

1. 系统化学习路径：本系列12篇文章循序渐进，带你完整掌握Go开发
2. 实战驱动教学：理论结合实践，每篇文章都有可操作的代码示例
3. 持续更新内容：定期分享最新Go生态技术动态与大厂实践经验
4. 专业技术社区：加入我们的技术交流群，与众多Go开发者共同成长

📱 关注方式

1. 微信公众号：搜索 “Gopher部落” 或 “GopherTribe”
2. 优快云专栏：点击页面右上角"关注"按钮

💡 读者福利

关注公众号回复 “Go学习” 即可获取：

• 完整Go学习路线图
• Go面试题大全PDF
• Go项目实战源码
• 定制学习计划指导

期待与您在Go语言的学习旅程中共同成长！