slice、string、map：Go 的三个内存模型陷阱

type slice struct {
    array unsafe.Pointer // 指向底层数组的指针
    len   int            // 当前长度
    cap   int            // 容量（从 array 开始到数组末尾的元素数）
}

if cap > doublecap {
    newcap = cap
} else {
    if old.len < 1024 {
        newcap = doublecap       // 翻倍
    } else {
        for 0 < newcap && newcap < cap {
            newcap += newcap / 4 // 1.25 倍增长，直到满足 cap
        }
    }
}

package main

import "fmt"

func main() {
    s := make([]int, 0)
    for i := 0; i < 20; i++ {
        s = append(s, i)
        fmt.Printf("len=%-3d cap=%-3d\n", len(s), cap(s))
    }
}

package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4, 5}
    b := a[1:3] // b = [2, 3]，但共享底层数组
    b[0] = 999
    fmt.Println(a) // [1 999 3 4 5] —— a 被悄悄改了
}

func process(src []int) []int {
    // 假设调用方传了 cap > len 的 slice
    src = append(src, 100)
    return src
}

func main() {
    a := make([]int, 2, 8) // cap=8，len=2
    a[0], a[1] = 1, 2
    b := process(a)
    fmt.Println(a, b) // [1 2 100] [1 2 100] —— 都变了
}

// 读一个 100MB 文件，截取第一行返回
func firstLine(data []byte) []byte {
    idx := bytes.IndexByte(data, '\n')
    return data[:idx] // 只用了 30 字节
}

func main() {
    data, _ := ioutil.ReadFile("huge.log") // data ~ 100MB
    line := firstLine(data)
    _ = line
    // data 之后没人引用了……吗？
}

return data[:idx:idx] // 第三个数字是 cap 上限
// 现在 line 的 cap = idx，append 会强制分配新数组

out := make([]byte, idx)
copy(out, data[:idx])
return out
// out 拥有独立的底层数组，data 一旦没人引用立即释放

type stringStruct struct {
    str unsafe.Pointer // 指向字节数组
    len int            // 字节长度（非字符数）
}

package main

import (
    "fmt"
    "testing"
)

var s = "hello, 世界"

// 标准库转换：拷贝
func toBytes(s string) []byte {
    return []byte(s)
}

// unsafe 零拷贝（危险！）
func toBytesUnsafe(s string) []byte {
    return unsafe.Slice((*byte)(unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&s)).Data)), len(s))
}

func BenchmarkStandard(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = toBytes(s)
    }
}

func BenchmarkUnsafe(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = toBytesUnsafe(s)
    }
}

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

func main() {
    s := "hello" // 指向只读数据段
    b := unsafe.Slice((*byte)(unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&s)).Data)), len(s))
    b[0] = 'H'  // 运行时崩溃：panic: fault on address ...
    fmt.Println(s)
}

s := "hello"
b := []byte(s)
// 此时编译器已经把 s 的内容缓存进寄存器
b[0] = 'H'
fmt.Println(s) // 仍可能输出 "hello"，因为编译器没重新从内存读

package main

import "fmt"

func main() {
    s := "hello, 世界"

    fmt.Println(len(s))        // 13（字节数）
    fmt.Println(utf8.RuneCountInString(s)) // 9（字符数）

    // 经典越界：按字符截取会爆
    for i, r := range s {
        fmt.Printf("byte=%d rune=%c\n", i, r)
    }
    // byte=0 rune=h
    // byte=1 rune=e
    // ...
    // byte=7 rune=,  ← 注意：逗号在索引 6，但 '世' 占 3 字节
    // byte=8 rune=世
    // byte=11 rune=界

    // 想取前 6 个字符，错误做法：
    // first6 := s[:6] // 只拿到 "hello,"，不是 6 个字符
    // first6 := s[:8] // "hello, 世"，但这是字节数
}

runes := []rune(s)
first3 := string(runes[:3]) // "hel" — 按字符数截取

type hmap struct {
    count     int            // 当前元素个数（len(mmap 返回值）
    flags     uint8
    B         uint8          // 桶数量 = 2^B
    noverflow uint16         // 溢出桶近似数
    hash0     uint32         // 哈希种子

    buckets    unsafe.Pointer // 桶数组首地址
    oldbuckets unsafe.Pointer // 扩容时旧桶数组
    nevacuate  uintptr        // 搬迁进度
    extra      *mapextra      // 溢出桶链表
}

type bmap struct {
    tophash [8]uint8   // 每槽存 key 哈希的高 8 位（用于快速筛选）
    // 紧跟着是 8 个 key、8 个 value
    // 最后是 overflow *bmap（指向溢出桶）
}

// 简化版源码
if oldbuckets != nil {
    // 先用旧 B 算旧桶号，桶内查找
    // 旧桶的 tophash 标记 evacuateX/evacuateY 表示已搬迁
}

m := map[string]int{"a": 1, "b": 2, "c": 3}
for k, v := range m {
    fmt.Println(k, v) // 每次顺序都不一样
}

// runtime/map.go: mapiterinit
it.startBucket = fastrandn(uint8(h.B))  // 随机起始桶
it.offset = uint8(fastrandn(8))         // 桶内随机起始槽

m := map[string]struct{ X, Y int }{
    "a": {1, 2},
}
m["a"].X = 10 // 编译错误：cannot assign to struct field m["a"].X in map

v := m["a"]
v.X = 10
m["a"] = v

m := map[string]*Point{
    "a": &Point{X: 1, Y: 2},
}
m["a"].X = 10 // 合法：修改的是指针指向的对象

go build -gcflags="-m" main.go 2>&1 | grep -E "escape|moved to heap"

package main

import (
    "fmt"
    "runtime"
)

func noPrealloc() []int {
    var s []int
    for i := 0; i < 10000; i++ {
        s = append(s, i) // 多次重新分配，约 14 次（1024 之前翻倍，之后 1.25 倍）
    }
    return s
}

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

func main() {
    var m1, m2 runtime.MemStats

    runtime.GC()
    noPrealloc()
    runtime.ReadMemStats(&m1)

    runtime.GC()
    prealloc()
    runtime.ReadMemStats(&m2)

    fmt.Printf("no prealloc: heap=%dKB mallocs=%d\n", m1.HeapAlloc/1024, m1.Mallocs)
    fmt.Printf("prealloc:    heap=%dKB mallocs=%d\n", m2.HeapAlloc/1024, m2.Mallocs)
}

// 已知会装 10000 个元素
m := make(map[string]int, 10000) // 提示 runtime 初始分配足够桶