Go Slice 底层结构与使用陷阱

type slice struct {
    array unsafe.Pointer // 指向底层数组的指针
    len   int            // 当前长度
    cap   int            // 容量
}

slice := make([]int, 3, 5)

┌────────┐
│ array  │─────→  ┌───┬───┬───┬───┬───┐
│ len=3  │       │ 0 │ 0 │ 0 │ ? │ ? │
│ cap=5  │       └───┴───┴───┴───┴───┘
└────────┘        ←── len ──→
                  ←────── cap ──────→

s := []int{1, 2}      // len=2, cap=2
s = append(s, 3)       // 触发扩容
// cap 变为 2 → 4 → 8 ...（翻倍增长，大切片 1.25 倍）

// 查看扩容行为
s := make([]int, 0)
for i := 0; i < 10; i++ {
    s = append(s, i)
    fmt.Printf("len=%d cap=%d\n", len(s), cap(s))
}
// len=1 cap=1
// len=2 cap=2
// len=3 cap=4
// len=4 cap=4
// len=5 cap=8
// ...

s1 := []int{1, 2, 3, 4, 5}
s2 := s1[1:3]  // s2 = [2, 3], len=2, cap=4（共享底层数组！）

s2[0] = 99
fmt.Println(s1)  // [1, 99, 3, 4, 5] ← s1 也被改了！

s2 = append(s2, 100)
fmt.Println(s1)  // [1, 99, 100, 4, 5] ← s1 又被改了！

底层数组：  ┌───┬───┬───┬───┬───┐
            │ 1 │ 2 │ 3 │ 4 │ 5 │
            └───┴───┴───┴───┴───┘
             ↑       ↑
s1:         从 0 开始，len=5, cap=5
s2:              从 1 开始，len=2, cap=4

// 方式一：完整截取 + append
s2 := append([]int{}, s1[1:3]...)

// 方式二：copy
s2 := make([]int, 2)
copy(s2, s1[1:3])

// 方式三：限制 cap
s2 := s1[1:3:3]  // len=2, cap=2（第三个值限制 cap）

func add(s []int) {
    s = append(s, 99)  // 只改函数内的 s，外部不受影响
}

func addPtr(s *[]int) {
    *s = append(*s, 99)  // 传指针才影响外部
}

func addAndReturn(s []int) []int {
    return append(s, 99)  // 返回新 slice
}

var s1 []int           // nil slice，len=0, cap=0, array=nil
s2 := []int{}          // empty slice，len=0, cap=0, array 有地址
s3 := make([]int, 0)   // empty slice

fmt.Println(s1 == nil) // true
fmt.Println(s2 == nil) // false

// JSON 编码差异
json.Marshal(s1)  // null
json.Marshal(s2)  // []

// 差：多次扩容 + 内存迁移
var s []int
for i := 0; i < 10000; i++ {
    s = append(s, i)
}

// 好：一次分配
s := make([]int, 0, 10000)
for i := 0; i < 10000; i++ {
    s = append(s, i)
}