Go 基础体系 · 第 7/113 篇。示例统一基于 Go 1.26.4；核心片段可能省略 package 与 import，完整程序可直接按文中结构运行。

Go 数组与切片：底层数组、扩容、内存保留与工程边界

本文所有代码与运行行为均以 Go 1.26.4 为基准。数组是长度属于类型一部分的值，切片则是描述某个底层数组连续窗口的值。二者语法相近，却有不同的复制、增长和所有权语义。大量“偶尔覆盖数据”“append 后修改失效”“只留几字节却占用几百 MiB”的问题，都来自把切片误当成可自动增长的独立数组。

可以把切片抽象为三个字段：指向窗口首元素的引用、长度 len 和容量 cap。这只是理解模型，不是允许业务依赖的内存布局。切片赋值和传参复制这三个信息，元素可能仍共享；append 是否迁移到底层新数组由容量和运行时增长策略决定。工程代码应围绕这些稳定语义设计，而不依赖某一版本的具体扩容倍数。

1. 数组的长度属于类型和值

[3]int 与 [4]int 是不同类型，不能直接赋值。数组赋值、参数传递和返回会复制全部元素；副本修改不影响原数组。数组零值是所有元素的零值，len 和 cap 都是编译期可确定的长度。

package main

import "fmt"

func change(a [3]int) {
	a[0] = 99
	fmt.Println("inside", a)
}

func main() {
	original := [3]int{10, 20, 30}
	copyOfArray := original
	copyOfArray[1] = 88
	change(original)
	fmt.Println("original", original)
	fmt.Println("copy", copyOfArray)
}

长度属于类型让数组适合表达固定协议块、哈希值和矩阵维度。例如 sha256.Sum256 返回 [32]byte，值天然可比较并可作 map 键。[...]T{...} 让编译器从字面量元素数推断长度，但结果仍是数组，不是切片。

向函数传大型数组可能复制较多数据；可以传 *[N]T，但通用顺序处理通常使用 []T 更自然。不要因为数组复制就完全回避它：固定长度本身能携带约束，可比较性和连续内存也很有价值。

2. 切片描述符：指针、长度和容量

切片类型写作 []T，不包含长度。对数组或切片执行 a[low:high] 得到窗口，长度为 high-low；容量通常从 low 延伸到底层数组末尾。两个切片可具有不同长度和容量，却覆盖同一批元素。

base := [6]int{10, 20, 30, 40, 50, 60}
left := base[1:4]  // [20 30 40]，len=3 cap=5
right := base[2:5] // [30 40 50]，len=3 cap=4
left[1] = 99       // 与 right[0]、base[2] 是同一元素
fmt.Println(base, left, right)

长度是当前可索引范围，合法索引为 0 <= i < len(s)；容量是不用重新分配即可把高边界扩到的上限。s[:cap(s)] 可以扩长度，但只能在容量范围内。索引越界或切片边界非法会 panic，外部输入决定边界时必须先验证，不能把 panic 当普通校验。

切片描述符按值传递。函数修改 s[i] 会改共享元素；执行 s = s[:0] 只修改函数自己的描述符；函数 append 后若要让调用者看到新长度和可能的新数组，必须返回新切片或传入 *[]T。惯用 API 通常返回切片，语义比二级修改更清晰。

3. nil 切片、空切片与零值契约

nil 切片的描述符不引用底层数组，len 和 cap 都为 0。它可以安全 range、append、copy 和 clear。[]T{} 或 make([]T, 0) 是非 nil 空切片，同样长度为 0，但与 nil 的状态不同。

var absent []int
empty := []int{}
fmt.Println(absent == nil, empty == nil) // true false
absent = append(absent, 1)               // 合法

切片不能彼此用 == 比较，只能与 nil 比较；内容比较可用 slices.Equal 或领域比较函数。nil 与空切片在许多内部算法中可同等对待，但 JSON 常分别编码为 null 与 []，数据库驱动和反射比较也可能区分。API 应在边界明确“缺失”和“存在但为空”是否不同。

返回列表的内部 Go API 常让 nil 表示无结果，以免无意义分配；面向客户端的 JSON 若契约要求数组，则应在编码 DTO 层规范为空切片。不要为统一风格在每个内部函数反复分配空切片。

4. make 的长度和容量不是一回事

make([]T, length, capacity) 创建底层数组并返回切片，第三个参数可省略，此时容量等于长度。长度为多少，就已经存在多少个可索引且带零值的元素。把期望元素数误写为长度，再 append，会在前面留下零值。

wrong := make([]int, 3)
wrong = append(wrong, 1, 2, 3)
fmt.Println(wrong) // [0 0 0 1 2 3]

right := make([]int, 0, 3)
right = append(right, 1, 2, 3)
fmt.Println(right) // [1 2 3]

已知最终长度且每个位置都会写入时，直接 make([]T, n) 后按索引填充，避免 append 更新长度；只知道上限或逐步筛选时，使用长度 0、预估容量。预分配减少重分配和复制，却会立刻保留相应内存，不能把不可信输入的声称数量直接作为巨大容量。

接收网络长度、文件头或分页参数时先检查非负、上限和整数转换。make([]byte, userSize) 对负值、超大值可能 panic 或导致内存压力，应在资源边界返回明确错误。

5. append 的稳定保证与不稳定细节

append 返回更新后的切片。若原容量足够，通常复用底层数组；否则分配一个更大的数组、复制旧元素并追加新值。必须写 s = append(s, value)，忽略返回值既可能丢失长度，也可能丢失迁移后的数组。

s := make([]int, 2, 2)
s[0], s[1] = 1, 2
before := &s[0]
s = append(s, 3)
after := &s[0]
fmt.Printf("moved=%t len=%d cap=%d values=%v\n", before != after, len(s), cap(s), s)

语言规范不承诺具体增长倍数。增长取决于旧容量、请求容量、元素大小、分配器规格和实现版本。代码只能依赖“返回切片包含原元素与追加元素”，不能断言容量必定翻倍，也不应基于一次观测推测生产内存。

append 可以把一个切片追加到另一个：dst = append(dst, src...)。源和目标重叠时，结果按语言规定应如同追加前的源元素序列，内建函数会正确处理；但复杂的原地移动仍应通过测试验证索引。Go 1.26 还可用 slices.Grow 确保额外容量，用 slices.Concat 清晰连接多个切片。

6. 三索引切片限制共享容量

完整切片表达式 s[low:high:max] 同时设置长度和容量，新容量为 max-low。它常用于把子切片交给可能 append 的函数时，禁止函数覆盖原数组后续元素。

func addMarker(s []string) []string {
	return append(s, "marker")
}

func exampleCapacityIsolation() {
	records := []string{"a", "b", "secret", "tail"}
	open := records[:2] // len=2 cap=4
	_ = addMarker(open) // 可能覆盖 records[2]

	limited := records[:2:2]   // len=2 cap=2
	added := addMarker(limited) // 必须分配新数组
	fmt.Println(records, added)
}

三索引切片是一种容量隔离，不是深拷贝。被包含的前两个元素仍共享，函数执行 s[0] = ... 仍会修改原数据；只有超出当前长度的 append 被迫迁移。若调用方需要完全所有权，使用 slices.Clone。

API 设计时不要依赖调用者理解隐藏容量。函数若保留输入或异步使用，明确复制；若只在调用期间读取，文档说明只读；若原地修改以减少分配，用名称、注释和测试表达这一契约。

7. copy、Clone 与重叠区域

内建 copy(dst, src) 复制 min(len(dst), len(src)) 个元素并返回数量。目标必须已有长度，只有容量没有长度仍复制 0 个。copy 支持源目标重叠，适合原地删除或移动。

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

buffer := []byte("abcdef")
copy(buffer[1:], buffer[:4])
fmt.Println(string(buffer)) // aabcdf

slices.Clone(s) 返回浅副本并保留 nil 性质，比 append([]T(nil), s...) 更直接。浅复制只隔离元素槽位：若元素是 *User、[]byte 或含 map 的结构体，其引用对象仍共享。复制深度应由业务类型定义。

复制也用于缩减容量和释放大数组引用：small := slices.Clone(huge[:10])。此后只要没有其他引用，原大数组可被 GC 回收。不要通过 unsafe 构造零复制切片绕开生命周期；省掉一次复制可能换来长期保留、并发污染甚至内存不安全。

8. 子切片为何会保留巨大内存

只要一个切片仍指向底层数组中的任一位置，整个包含相关对象引用的底层存储就可能保持可达。读取 100 MiB 文件后返回其中 20 字节的子切片，调用方长期保存它，就可能让 100 MiB 数组无法回收。

func header(packet []byte) ([]byte, error) {
	if len(packet) < 20 {
		return nil, errors.New("short packet")
	}
	return bytes.Clone(packet[:20]), nil
}

是否复制取决于大小比例和生命周期。短期解析函数立即消费子切片，零复制通常合适；小结果跨请求、进入缓存或长期对象时，复制能切断大数组。heap profile 中看到大 []byte 由很小对象链保留，应检查切片容量、缓存和解析 API 返回值。

将切片设为 nil 只移除当前变量的引用，其他别名仍可保留数组；runtime.GC() 也不能回收可达对象。修复应减少引用范围、复制所需片段或改变流式处理，而不是强制 GC。

9. 删除、清空与指针元素滞留

常见稳定删除可用 copy(s[i:], s[i+1:]) 后缩短长度；不要求顺序时，用最后元素覆盖待删位置再缩短。若元素含指针，缩短前最好把不再使用的尾部槽位置零，避免底层数组仍保存引用而延长对象生命周期。

func deleteAt[T any](s []T, i int) ([]T, error) {
	if i < 0 || i >= len(s) {
		return s, fmt.Errorf("index %d outside length %d", i, len(s))
	}
	copy(s[i:], s[i+1:])
	var zero T
	s[len(s)-1] = zero
	return s[:len(s)-1], nil
}

Go 1.26 的 slices.Delete、DeleteFunc、Compact 等函数会按照其文档处理被移除区域，并减少手写错误。clear(s) 将当前长度范围内的元素设为零，不改变长度或容量；s = s[:0] 只把长度变为零，旧槽位内容仍在底层数组中。

对于 []*BigObject 或含引用字段的元素，若切片会长期复用，clear(s) 后再 s = s[:0] 可解除引用。对于纯数值，清零只增加写入成本，是否需要取决于安全要求和复用逻辑。

10. range、迭代值与修改陷阱

for i, value := range s 中的 value 是元素值副本。修改 value 不会修改切片元素；应使用索引 s[i]。若元素是指针，复制指针后经它修改对象会生效，这仍符合值复制模型。

type Item struct{ Count int }

items := []Item{{1}, {2}}
for _, item := range items {
	item.Count++ // 只修改每轮副本
}
for i := range items {
	items[i].Count++ // 修改原元素
}

遍历期间 append 的行为应谨慎。range 在开始时对切片描述符求值，迭代次数基于初始长度；append 可能修改共享数组，也可能迁移，因此循环体看到什么容易依赖容量。除非算法有明确证明和测试，遍历输入时把输出追加到另一个切片。

切片被多个 goroutine 并发读取是安全的，前提是没有任何一方修改元素或切片覆盖的共享数据。不同 goroutine 写不重叠元素通常不形成同一地址的数据竞争，但若同时 append、重切片或对象间有更深层共享，仍可能出错。所有权分片必须在并发启动前固定。

11. 排序、比较和泛型标准库

切片不可用 == 比较内容。slices.Equal 比较可比较元素；slices.EqualFunc 支持自定义相等。slices.Sort 对有序元素原地排序，SortFunc 接受三向比较函数。排序修改原切片及其共享底层数组，需要保留原顺序时先 Clone。

users := []User{{ID: 2, Name: "B"}, {ID: 1, Name: "A"}}
sorted := slices.Clone(users)
slices.SortFunc(sorted, func(a, b User) int {
	return cmp.Compare(a.ID, b.ID)
})

比较函数必须形成一致的顺序；不能用 return a.ID-b.ID，整数减法可能溢出。浮点 NaN、大小写和本地化文本也需要定义明确规则。测试输出若依赖顺序，应在输出边界排序，而不是误以为输入 map 或并发结果自然稳定。

标准库 slices 包封装了常见正确操作，但不会替你决定所有权。Clone 是浅复制，排序是原地操作，某些函数会改变长度或清理尾部；使用前仍要阅读函数契约并测试 nil、空、单元素和重复元素。

12. 性能、诊断与容量预算

切片性能主要来自连续存储和较少分配。已知规模时预分配；处理大对象时关注峰值容量；对象包含大量指针时，过大的闲置底层数组会增加 GC 扫描与保留成本。不要只优化 allocs/op，还要检查保留内存和 P99。

go test -bench=BenchmarkBuild -benchmem -count=5 ./...
go test -run TestSlice -count=100 ./...
go test -race ./...
go tool pprof -alloc_space mem.pprof

排查覆盖问题时打印 len、cap，并在非空时比较 &s[0]，可以确认几个切片是否从同一位置开始；但地址只用于诊断，不能成为业务判断。排查越界 panic 先读完整栈，再检查边界来自哪里以及零长度是否被遗漏。

增长热点可用 benchmark 对比无预分配、合理预分配和过度预分配。具体扩容策略属于实现细节，升级 Go 后应重新测量。池化切片可能减少分配，却可能让偶发巨大容量长期滞留；归还池前设置容量上限，超大缓冲直接丢弃更稳妥。

13. 综合示例：有界批处理与所有权隔离

下面程序解析整数、分批求和，并演示安全的输入复制和容量控制。ParseBatch 不保留调用方字节切片；结果按已验证的上限预分配。Chunk 用三索引表达式把每批容量限制为长度，防止消费者 append 覆盖后续批次。

package main

import (
	"errors"
	"fmt"
	"slices"
	"strconv"
	"strings"
)

const maxItems = 1000

func ParseBatch(input []byte) ([]int, error) {
	text := strings.TrimSpace(string(input))
	if text == "" {
		return []int{}, nil
	}
	fields := strings.Split(text, ",")
	if len(fields) > maxItems {
		return nil, fmt.Errorf("too many items: %d", len(fields))
	}
	values := make([]int, 0, len(fields))
	for i, field := range fields {
		value, err := strconv.Atoi(strings.TrimSpace(field))
		if err != nil {
			return nil, fmt.Errorf("item %d: %w", i, err)
		}
		values = append(values, value)
	}
	return values, nil
}

func Chunk[T any](values []T, size int) ([][]T, error) {
	if size <= 0 {
		return nil, errors.New("chunk size must be positive")
	}
	chunks := make([][]T, 0, (len(values)+size-1)/size)
	for len(values) > 0 {
		n := min(size, len(values))
		chunks = append(chunks, values[:n:n])
		values = values[n:]
	}
	return chunks, nil
}

func sum(values []int) int {
	total := 0
	for _, value := range values {
		total += value
	}
	return total
}

func main() {
	values, err := ParseBatch([]byte("8, 3, 5, 2, 9"))
	if err != nil {
		panic(err)
	}
	original := slices.Clone(values)
	slices.Sort(values)

	chunks, err := Chunk(values, 2)
	if err != nil {
		panic(err)
	}
	for i, chunk := range chunks {
		extended := append(chunk, 100) // cap 被限制，不会覆盖下一批
		fmt.Printf("chunk=%d values=%v sum=%d extended=%v\n",
			i, chunk, sum(chunk), extended)
	}
	fmt.Println("original:", original)
	fmt.Println("sorted:", values)
}

保存后可执行：

gofmt -w main.go
go run -race main.go
go test -race ./...

程序中的每一步都体现一个边界：输入数量先验证再分配，排序前保留原始副本，分批只共享只读元素，容量限制使消费者追加时自动获得新数组。如果批次要跨 goroutine 且消费者可能修改已有元素，则三索引仍不够，必须对每批 slices.Clone 或把所有权完整移交。切片优化的核心不是背扩容公式，而是持续回答“这个描述符指向谁、谁还能修改底层数组、引用要活多久”。

系列导航与关联阅读

官方资料

本文依据 Go 官方规范、标准库文档和 Go 官方博客重新梳理；正文与示例由 WR BLOG 编写。

Go 数组与切片：长度、容量、扩容和底层数组