作为Go语言开发者，在日常编码中，我们经常会面临这样的选择：该用数组还是切片？这两者看起来相似，但实际特性却大不相同。下面就来彻底搞懂它们的区别！

基本概念：固定 vs 动态

数组就像固定大小的容器：一旦创建，容量就不能改变。它的长度甚至是类型的一部分：

// 数组声明示例
var arr1 [3]int          // 声明长度为3的int数组
arr2 := [3]int{1, 2, 3}  // 声明并初始化
arr3 := [...]int{1,2,3}  // 编译器推导长度

重要的是，[3]int和[5]int在Go语言中是完全不同的类型，不能互相赋值或比较。

切片则更像是可以自动扩容的"智能容器"，它提供了对底层数组的动态视图：

// 切片声明示例
var s1 []int              // 未初始化的切片（nil切片）
s2 := make([]int, 3)      // 长度和容量都为3的切片
s3 := []int{1, 2, 3}      // 声明并初始化

切片可以随时扩展，非常适合处理不确定数量的数据。

底层结构：值类型 vs 引用类型

这是两者最核心的区别，也直接决定了它们的行为特性。

数组是值类型，变量直接代表整个数据集合。当你将一个数组赋值给另一个变量或传递给函数时，会发生完整复制：

func main() {
    arr1 := [3]int{1, 2, 3}
    arr2 := arr1          // 整个数组被复制
    arr2[0] = 100         // 只修改arr2，不影响arr1
    fmt.Println(arr1)     // [1, 2, 3]
    fmt.Println(arr2)     // [100, 2, 3]
}

切片则是引用类型，它本身只是一个"描述符"，包含三个字段：

• 指针：指向底层数组的起始位置
• 长度：当前包含的元素个数
• 容量：从起始位置到底层数组末尾的元素个数

当切片被传递时，复制的只是这个描述符，底层数组仍然是共享的：

func main() {
    slice1 := []int{1, 2, 3}
    slice2 := slice1       // 只复制切片描述符
    slice2[0] = 100        // 修改会影响两个切片
    fmt.Println(slice1)    // [100, 2, 3]
    fmt.Println(slice2)    // [100, 2, 3]
}

动态扩容：切片的独门绝技

切片最强大的特性就是可以动态扩容。当使用append函数添加元素时，如果容量不足，Go会自动进行扩容：

s := []int{1, 2, 3}
fmt.Println(len(s), cap(s)) // 3, 3
s = append(s, 4)           // 触发扩容
fmt.Println(len(s), cap(s)) // 4, 6（通常2倍扩容）

扩容策略一般是：容量小于1024时翻倍，超过1024后按1.25倍增长。

使用场景：各有所长

优先使用数组的情况：

• 数据长度在编译时已知（如颜色值[3]byte）
• 需要严格控制内存布局（如与C语言交互）
• 需要值语义，希望每次赋值都产生独立副本

优先使用切片的情况：

• 需要动态大小的集合（大多数场景）
• 需要频繁添加或删除元素
• 作为函数参数传递，避免复制开销
• 实现队列、栈等动态数据结构

实战技巧与避坑指南

1. 预分配优化性能

如果知道大致容量，提前分配可以避免频繁扩容：

// 低效方式
var s []int
for i := 0; i < 1000; i++ {
    s = append(s, i)
}

// 高效方式
s := make([]int, 0, 1000) // 预分配容量
for i := 0; i < 1000; i++ {
    s = append(s, i)
}

2. 避免意外的数据共享

由于多个切片可能共享底层数组，修改一个切片可能影响另一个：

original := []int{1,2,3,4,5}
subSlice := original[1:3]    // [2,3]
subSlice[0] = 99             // 会影响original！
fmt.Println(original)        // [1,99,3,4,5]

解决方案：使用copy创建独立副本：

subSlice := make([]int, 2)
copy(subSlice, original[1:3]) // 独立复制数据
subSlice[0] = 99              // 不影响original

3. 空切片 vs nil切片

这两者在使用上相似，但有细微差别：

var nilSlice []int        // nil切片，未指向任何底层数组
emptySlice := []int{}     // 空切片，有底层数组但为空

fmt.Println(nilSlice == nil)   // true
fmt.Println(emptySlice == nil) // false

一般建议：函数返回错误时返回nil切片，返回空集合时使用空切片。

总结对比

为了让您更直观地理解，我们用表格总结一下关键区别：

选择建议

对于Go语言新手，我的建议是：大多数情况下优先使用切片。切片更灵活，更符合Go语言的使用习惯，能够处理大多数实际场景。

只有当您确实需要固定大小、值语义的特性时，才考虑使用数组。记住这个经验法则：当不确定大小时总是使用切片；当需要精确内存控制时考虑数组。