Go中的切片（Slice）底层原理与操作陷阱

1. 切片是什么？

切片（Slice）是 Go 中一种动态数组结构，由三个核心字段组成：

• 指针：指向底层数组的起始元素（切片第一个元素对应的数组位置）
• 长度（len）：当前切片包含的元素个数
• 容量（cap）：从切片起始位置到底层数组末尾的元素个数

示例：

arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:3] // 切片s指向arr[1]到arr[2]，len=2, cap=4（从arr[1]到arr[4]）

2. 切片的创建方式

（1）直接声明

var s1 []int          // 此时s1为nil，len=0, cap=0
s2 := []int{1, 2, 3}  // 底层数组为[1,2,3]，len=cap=3

（2）通过make创建

s := make([]int, 3, 5) // len=3, cap=5，底层数组初始化为0值

（3）从数组或切片截取

arr := [3]int{1, 2, 3}
s := arr[0:2]         // 与原数组共享内存

3. 底层数组共享与内存陷阱

关键规则：

• 多个切片可能共享同一底层数组，修改元素会相互影响
• 扩容机制：当追加元素超过容量时，会分配新数组（容量通常按1.5倍或2倍增长）

示例1：共享修改

s1 := []int{1, 2, 3}
s2 := s1[:2]          // s2=[1,2], cap=3
s2[0] = 9             // 修改底层数组
fmt.Println(s1)        // [9,2,3]！s1受影响

示例2：扩容后分离

s1 := []int{1, 2, 3}
s2 := append(s1, 4)   // s1容量为3，追加后容量不足，s2指向新数组
s2[0] = 9             
fmt.Println(s1)        // [1,2,3]（不变）

4. 常见操作陷阱分析

（1）截取操作导致容量泄漏

func main() {
    s1 := make([]int, 0, 10)
    s2 := s1[:5]       // s2的cap=10，但实际只用了5个
    // 此时底层数组整个10个元素无法被GC回收，即使s2只使用5个！
}

解决方法：明确指定容量

s2 := s1[:5:5]        // 第三个参数限制cap=5，避免内存泄漏

（2）函数传参的误解

func appendSlice(s []int) {
    s = append(s, 100) // 如果扩容，s会指向新数组，但外部切片仍指向原数组
}

func main() {
    s := make([]int, 2, 3)
    appendSlice(s)
    fmt.Println(s)     // [0,0]（未改变！）
}

原理：切片是结构体（指针+len+cap）的值传递，函数内修改指针指向外部不可见。
正确做法：返回修改后的切片或使用指针

func appendSlice(s *[]int) {
    *s = append(*s, 100)
}

5. 切片与性能优化

（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）大切片复用

使用 copy 替代重切片：

// 错误：s2仍引用大数组
s1 := make([]int, 10000)
s2 := s1[:10]         // 底层数组10000个元素无法释放

// 正确：复制数据到新切片
s2 := make([]int, 10)
copy(s2, s1)

6. 总结要点

• 切片是引用类型，但本质是结构体的值传递
• 理解底层数组共享机制，避免意外修改
• 注意容量和长度的区别，截取时警惕内存泄漏
• 扩容会导致底层数组变更，必要时返回新切片或使用指针