1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

数组 [3]int              切片 []int
┌────┬────┬────┐        ┌─────────┬─────┬─────┐
│ 1  │ 2  │ 3  │        │ ptr ────┼─► │ len │ cap │
└────┴────┴────┘        └─────────┴─────┴─────┘
 赋值 = 拷贝 3 个 int      赋值 = 拷贝 1 指针 + 2 个 int（24 字节）
                          指向同一个底层数组 ⚠️

底层数组（堆上）
┌────┬────┬────┬────┬────┐
│ 1  │ 2  │ 3  │ 4  │ 5  │
└────┴────┴────┴────┴────┘
  ▲         ▲
  │         │
完整切片    子切片（共享同一块内存）

1
2
3

func byValue(a [1000000]int) { }   // 🛑 每次调用拷贝 8 MB
func bySlice(a []int)        { }   // ✅ 只拷贝 24 字节头部
func byPointer(a *[1000000]int) { } // ✅ 只传指针

1
2
3
4
5
6
7
8

s := make([]int, 2, 5)   // len=2, cap=5，前 2 个元素是零值
s = append(s, 1)         // len=3, cap=5（还有空间，不扩容）

l := []int{1, 2, 3}      // len=3, cap=3（字面量 cap 通常=len）

arr := [5]int{1, 2, 3, 4, 5}
sl := arr[1:3]           // len=2, cap=4 ← cap 是「从起点到数组末尾」🔥
sl2 := sl[1:2]           // len=1, cap=3

1
2
3
4
5

make([]int,2,5): [0 0] 2 5
after append 1: [0 0 1] 3 5
literal: [1 2 3] 3 3
arr[1:3]: [2 3] 2 4
sl[1:2]: [3] 1 3

1
2
3

full := []int{1, 2, 3, 4, 5}
limited := full[1:3:3]
fmt.Println("full[1:3:3]:", limited, len(limited), cap(limited))

1

full[1:3:3]: [2 3] 2 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

两条路径的内存实况

【路径一】cap 还够 → 原地写
  s := make([]int, 3, 5)        b := append(s, 4)
  s ┌───────┬─────┬─────┐       b ┌───────┬─────┬─────┐
    │ ptr ──┼─►3  │  3  │ 5       │ ptr ──┼─►3  │  4  │ 5
    └───────┴─────┴─────┘         └───────┴─────┴─────┘
            │                             │
            └──────────┬──────────────────┘
                       ▼
            ┌────┬────┬────┬────┬────┐
            │ 1  │ 2  │ 3  │ 4  │    │  ◄── 同一个底层数组 ⚠️
            └────┴────┴────┴────┴────┘
            b[0]=100 会同时改掉 s[0]！

【路径二】cap 用尽 → 另起炉灶
  s := make([]int, 3, 3)        b := append(s, 4)
  s ┌───────┬─────┬─────┐       b ┌───────┬─────┬─────┐
    │ ptr ──┼─►A  │  3  │ 3       │ ptr ──┼─►B  │  4  │ 4
    └───────┴─────┴─────┘         └───────┴─────┴─────┘
            │                             │
            ▼                             ▼
     ┌────┬────┬────┐              ┌────┬────┬────┬────┐
     │ 1  │ 2  │ 3  │  A           │ 1  │ 2  │ 3  │ 4  │  B
     └────┴────┴────┘              └────┴────┴────┴────┘
     完全独立 ✅ 改 b 不影响 s

结论：append 是否「安全」取决于 cap，而不是你的意图 ⚠️
     要确定性 → slices.Clone 或三索引切片把 cap 卡死

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 场景 1：还有容量 → 共享
a := make([]int, 3, 5)
copy(a, []int{1, 2, 3})
b := append(a, 4)
b[0] = 100
fmt.Println("share cap: a =", a, " b =", b)

// 场景 2：容量用尽 → 分离
c := make([]int, 3, 3)
copy(c, []int{1, 2, 3})
d := append(c, 4)
d[0] = 100
fmt.Println("grown:    c =", c, " d =", d)

1
2

share cap: a = [100 2 3]  b = [100 2 3 4]     ← a 被意外改掉了 ⚠️
grown:    c = [1 2 3]  d = [100 2 3 4]        ← c 安全 ✅

1
2
3
4
5

full := []int{1, 2, 3, 4, 5}
limited := full[1:3:3]              // cap 卡到 2
pushed := append(limited, 42)       // 必须扩容
pushed[0] = 77
fmt.Println("after append to limited:", full, pushed)

1

after append to limited: [1 2 3 4 5] [77 3 42]   ← full 完好 ✅

1
2
3
4

full := []int{1, 2, 3, 4, 5}
view := full[1:3]              // cap=4，还有空间！
view = append(view, 42)        // 原地写入 full[3]
fmt.Println(full)              // [1 2 3 42 5] ⚠️ 原数组被改了

1
2
3

safe := slices.Clone(full[1:3:3])
safe[0] = 55
fmt.Println("cloned safe:", safe, "full untouched:", full)

1

cloned safe: [55 3] full untouched: [1 2 3 4 5]

1
2
3
4
5
6
7
8
9

var s []int
prev := 0
for range 12 {
	s = append(s, 1)
	if cap(s) != prev {
		fmt.Printf("len=%d cap=%d\n", len(s), cap(s))
		prev = cap(s)
	}
}

1
2
3

len=1 cap=4
len=5 cap=8
len=9 cap=16

1
2
3
4
5

big := make([]int, 0, 1000)
for range 1000 {
	big = append(big, 1)
}
fmt.Println("preallocated:", len(big), cap(big))

1

preallocated: 1000 1000

1
2
3
4
5
6
7
8

src := []int{1, 2, 3, 4, 5}
dst := make([]int, 3)
n := copy(dst, src)
fmt.Println("copy 3:", dst, "n =", n)

overlap := []int{1, 2, 3, 4, 5}
copy(overlap[1:], overlap[:4])   // copy 能正确处理重叠
fmt.Println("overlap:", overlap)

1
2

copy 3: [1 2 3] n = 3
overlap: [1 1 2 3 4]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

kept := make([][]byte, 0, 8)
for range 8 {
	big := bigSlice()          // 每次 4 MiB
	kept = append(kept, big[:16])   // ⚠️ 只留 16 字节
}
fmt.Printf("window kept:  heap %d MiB -> %d MiB\n", start, heapMiB())

kept2 := make([][]byte, 0, 8)
for range 8 {
	big := bigSlice()
	kept2 = append(kept2, slices.Clone(big[:16]))   // ✅ 拷贝独立小切片
}
fmt.Printf("cloned small: heap %d MiB -> %d MiB\n", start2, heapMiB())

1
2

window kept:  heap 0 MiB -> 32 MiB
cloned small: heap 0 MiB -> 0 MiB

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

map[string]int 的内部结构（简化）
┌──────────────────────────────────────────┐
│ hmap: count, flags, B(桶数量=2^B), ...    │
│       buckets ─────────────┐              │
└────────────────────────────┼──────────────┘
                             ▼
        ┌─────────────┬─────────────┬─────────────┐
        │ bucket 0    │ bucket 1    │ bucket 2    │
        │ tophash[8]  │ tophash[8]  │ tophash[8]  │
        │ keys[8]     │ keys[8]     │ keys[8]     │
        │ values[8]   │ values[8]   │ values[8]   │
        │ overflow ───┼──► 溢出桶    │             │
        └─────────────┴─────────────┴─────────────┘

1
2
3
4
5
6
7
8
9

m1 := map[string]int{"a": 1}       // 字面量
m2 := make(map[string]int)         // 空 map，可写 ✅
m3 := make(map[string]int, 100)    // 预分配，减少扩容
// var m4 map[string]int           // ⚠️ nil map，读可以，写 panic

v, ok := m1["a"]                   // 取值 + 存在性 🔥
v2, ok2 := m1["missing"]           // v2 = 0, ok2 = false
delete(m1, "missing")              // 删不存在的键是安全的，无操作
len(m1)                            // 键值对数量

1
2
3
4

map[a:1] 0 0
comma-ok: 1 true
missing: 0 false
delete noop ok, len = 1

1
2
3

type Point struct{ X, Y int }
grid := map[Point]string{{0, 0}: "origin"}
fmt.Println("struct key:", grid[Point{0, 0}])

1

struct key: origin

1
2
3
4
5

m := map[string]int{"c": 3, "a": 1, "b": 2}
keys2 := slices.Collect(maps.Keys(m))
fmt.Println("unsorted:", keys2)                    // 每次运行可能不同 ⚠️
keys := slices.Sorted(maps.Keys(m))
fmt.Println("sorted keys:", keys)                  // 稳定 ✅

1
2

sorted keys: [a b c]
unsorted: [c a b]

1
2
3
4
5
6
7
8
9

// 🛑 并发写 map 会 panic（fatal error: concurrent map writes），无法 recover
var m = map[string]int{}
go func() { m["a"] = 1 }()
go func() { m["b"] = 2 }()

// ✅ 三种正确做法
mu.Lock(); m["a"] = 1; mu.Unlock()          // 1. Mutex
var sm sync.Map                              // 2. sync.Map（读多写少）
// 3. 每个 goroutine 用局部 map，最后合并

1

fmt.Println("maps.Equal:", maps.Equal(map[string]int{"a": 1}, map[string]int{"a": 1}))

1

maps.Equal: true

1
2
3
4
5
6
7

type Bad struct {          type Good struct {
    A bool   // off 0        B int64  // off 0
    (pad 7)  //              A bool   // off 8
    B int64  // off 8        C bool   // off 9
    C bool   // off 16       (pad 6)  //
    (pad 7)  //              }         // size 16 ✅
}             // size 24 ⚠️

1
2
3

fmt.Println("Bad  size:", unsafe.Sizeof(Bad{}), "align:", unsafe.Alignof(Bad{}))
fmt.Println("Good size:", unsafe.Sizeof(Good{}))
fmt.Println("offsets Bad:", unsafe.Offsetof(Bad{}.A), unsafe.Offsetof(Bad{}.B), unsafe.Offsetof(Bad{}.C))

1
2
3

Bad  size: 24 align: 8
Good size: 16
offsets Bad: 0 8 16

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type Tagged struct {
	ID       int    `json:"id" db:"user_id"`
	Name     string `json:"name,omitempty"`
	internal string
}

t := reflect.TypeOf(Tagged{})
for i := range t.NumField() {
	f := t.Field(i)
	fmt.Printf("%-10s %-8s tag=%q exported=%v\n", f.Name, f.Type, f.Tag, f.IsExported())
}
fmt.Println("Tag.Get:", t.Field(0).Tag.Get("json"), "|", t.Field(0).Tag.Get("db"))

1
2
3
4

ID         int      tag="json:\"id\" db:\"user_id\"" exported=true
Name       string   tag="json:\"name,omitempty\"" exported=true
internal   string   tag="" exported=false
Tag.Get: id | user_id

1
2

type P struct{ X, Y int }
fmt.Println("comparable:", P{1, 2} == P{1, 2})

1

comparable: true