罗罗编程学习记录
本页内容 展开查看

04.3.1.2 slice、array 与扩容机制

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.3 Go / 04.3.1 语言核心与内存

04.3.1.2-001 array 和 slice 有什么区别?

一句话结论

array 是固定长度的值类型,长度属于类型的一部分;slice 是引用视图结构,长度可变,底层指向一个数组。

概念解释

数组赋值会复制整个元素;切片只复制三字段头,共享底层数组。数组长度在编译期确定,切片通过 len/cap 描述可用空间。

原理流程

  1. 声明数组:类型含长度,存储连续元素。
  2. 声明切片:头指针指向底层数组。
  3. 赋值/传参时数组复制,切片共享底层。

代码或图示

var arr [5]int      // 长度 5 的数组
var s []int         // 切片,len=0
s = arr[:]

常见误区

  • 把 [5]int 和 []int 当同一类型:长度不同的数组类型互不兼容。
  • 切片赋值会复制底层数组:只复制切片头,数组共享。

追问

  • 数组适合什么场景?答:长度固定、需值语义的小固定集合;动态集合用 slice。
  • 数组是值类型还是引用类型?答:数组是值类型,赋值与传参整体拷贝;slice 是引用语义的描述头,底层数组共享。

04.3.1.2-002 slice 的底层结构是什么?

一句话结论

slice 头由指向底层数组的指针、长度 len、容量 cap 三个字段组成;len 是当前元素个数,cap 是从指针位置起可容纳的元素数。

概念解释

切片头本身很小,复制传递廉价。底层数组在堆或栈上分配,多个切片可指向同一数组的不同区间。

原理流程

  1. 指针定位底层数组起始位置。
  2. len 限定可读写范围。
  3. cap 记录剩余可扩展空间。

代码或图示

slice header: { ptr *Elem, len int, cap int }

常见误区

  • 认为 slice 就是数组:它是数组上的描述头。
  • len 与 cap 混淆:len 是已用长度,cap 是底层可用容量。

追问

  • 切片字面量初始化?答:Go 自动分配底层数组并返回指向它的切片头。
  • 切片头三字段是什么?答:pointer(底层数组指针)、len(长度)、cap(容量)。

04.3.1.2-003 append 什么时候分配新底层数组?

一句话结论

append 后长度超过当前 cap 时触发扩容,分配更大的新数组、拷贝旧元素,再追加新值;cap 足够时直接在原数组写入并增大 len。

概念解释

扩容是否发生取决于追加后长度是否超出容量。旧数组可能被多切片引用,扩容拷贝避免破坏其他视图。

原理流程

  1. 计算追加后所需长度。
  2. cap 足够 → 原地写入。
  3. cap 不足 → 扩容分配、拷贝、返回新切片。

代码或图示

s := make([]int, 0, 2)
s = append(s, 1, 2, 3) // 第 3 个元素触发扩容

常见误区

  • append 一定会复制数组:容量足够时原地追加。
  • 忽略 append 返回值:切片头(ptr/len/cap)可能已变,必须接收返回值。

追问

  • 扩容后旧底层数组?答:无引用时由 GC 回收;有其他切片引用则保留。
  • 容量怎么判断够不够?答:len + n <= cap 时原地追加;超出 cap 才分配新底层数组并拷贝。

04.3.1.2-004 slice 扩容策略是怎样的?

一句话结论

小容量阶段容量大致翻倍,容量增大后增长比例趋于平缓以避免过度浪费;具体阈值与倍数随 Go 版本调整,以当前版本源码/文档为准。

概念解释

扩容既要减少拷贝次数,又不能过度预留内存。早期 Go 小切片翻倍、大切片按更平缓比例增长;版本间有过调整,不应背固定数字。

原理流程

  1. 估算所需新容量。
  2. 按当前容量选择增长规则。
  3. 对齐内存分配粒度后分配新数组。

代码或图示

小 cap:近似翻倍;大 cap:平缓增长(具体倍数以当前版本为准)

常见误区

  • 记住某一版本固定倍数当通用结论:扩容规则随版本演进。
  • 认为扩容只看追加元素个数:还受底层数组分配粒度影响。

追问

  • 待确认:当前版本扩容公式,可查 runtime.growslice 源码核对。
  • 小容量与大容量区别?答:小容量按较大倍数快速增长,容量增大后倍数趋缓并考虑内存分配粒度;具体阈值以 growslice 源码为准。

04.3.1.2-005 子切片共享底层数组会带来什么问题?

一句话结论

从切片切出的新切片共享同一底层数组,修改任一侧元素会影响另一侧;旧数组虽不再整体使用,仍被子切片引用而无法回收。

概念解释

切片表达式 s[low:high] 只建视图,不拷贝数据。共享视图方便,但容易出现意外改写与内存滞留(大数组被小子切片挂住)。

原理流程

  1. 父切片底层数组被多个子切片指向。
  2. 子切片写入落到共享数组。
  3. 只要子切片存活,整个底层数组不能回收。

代码或图示

a := make([]int, 1000)
b := a[:2] // b 引用整个 1000 元素数组

常见误区

  • 子切片是独立副本:默认共享底层数组。
  • 只持有小子切片就不会占用大数组:底层数组由引用决定存活。

追问

  • 切断共享怎么做?答:用 copy 把需要的元素复制到新切片。
  • 为什么小子切片占大数组?答:底层数组整块被切片头引用,只要子切片存活,整个原数组就不能回收。

04.3.1.2-006 copy 与 append 在复制数据上有什么区别?

一句话结论

copy(dst, src) 把元素按较少长度复制到独立底层数组;append 在目标容量不足时才扩容拷贝,可能仍与原数组相关。

概念解释

需要独立副本、避免共享改写时用 copy。append 是追加语义,复制只发生在扩容路径。

原理流程

  1. 准备目标切片(预分配足够 cap)。
  2. copy 逐元素复制。
  3. 目标与源底层数组分离。

代码或图示

dst := make([]int, len(src))
copy(dst, src)

常见误区

  • 目标切片 cap 不足导致 copy 不完整:copy 复制长度取 min(len(dst), len(src))。
  • 用 append 拼接当深拷贝:扩容才拷贝,未必独立。

追问

  • copy 返回值?答:实际复制的元素个数。
  • copy 目标长度不足?答:只复制 min(len(dst), len(src)) 个元素,不会自动扩容目标切片。

04.3.1.2-007 nil slice 与空 slice 有什么区别?

一句话结论

nil slice 指针为 nil、len/cap 为 0;空 slice 指向长度为 0 的底层数组。两者 len 都是 0,但内部指针状态不同,序列化/判空表现可能有差异。

概念解释

var s []int 是 nil;make([]int, 0) 是空切片。多数遍历、append 行为一致,但 JSON 序列化等场景对 nil 与空切片输出不同。

原理流程

  1. 声明未初始化切片 → nil。
  2. make 零长度切片 → 非 nil 空数组。
  3. 按场景选择初始化方式。

代码或图示

var a []int        // nil
b := make([]int, 0) // 空,非 nil

常见误区

  • 用 == nil 判断切片是否为空:空切片非 nil 但 len 为 0,判空应看 len。
  • 混淆两者的 JSON 输出:nil 常序列化为 null,空切片为 []。

追问

  • 待确认:具体序列化行为按所用编码库核对。
  • 两者 len/cap 怎样?答:nil slice 的 ptr/len/cap 均为 0;空切片 make([]T,0) len/cap 为 0 但 ptr 可能非 nil。

04.3.1.2-008 slice 作为函数参数传递会复制什么?

一句话结论

传递的是切片头副本(指针、len、cap),底层数组共享;在函数内追加若触发扩容,新底层数组不会反映到原切片头。

概念解释

改元素内容通过共享数组生效;改变切片头本身(扩容后新指针)需要返回新切片或传入切片指针。

原理流程

  1. 调用时复制切片头。
  2. 修改元素 → 作用于共享数组。
  3. 扩容后返回新头,由调用方接收。

代码或图示

func add(s []int) []int { return append(s, 1) }
s = add(s) // 必须接收返回值

常见误区

  • 函数内 append 后调用方自动看到新长度:头副本不回传。
  • 以为传参复制了整个数组:只复制三字段头。

追问

  • 想在函数内改切片头?答:传 *[]int 或返回新切片。
  • 函数内改元素会反映到调用方吗?答:会,因为共享底层数组;但 append 产生的新切片头不会回传。

04.3.1.2-009 如何预分配切片容量避免反复扩容?

一句话结论

已知元素数量时用 make([]T, 0, n) 预留 cap,append 不再扩容;需要直接填充长度则 make([]T, n)。

概念解释

反复扩容伴随多次分配与拷贝。预分配把成本前置,循环构建切片时收益明显。

原理流程

  1. 估算最终元素数 n。
  2. make 预留 cap n。
  3. 循环 append,原地写入无扩容拷贝。

代码或图示

s := make([]int, 0, len(input))
for _, v := range input { s = append(s, v*2) }

常见误区

  • 预分配过大造成内存浪费:数量估算应贴合实际分布。
  • make 第二参数是 cap:make([]T, len, cap),顺序不要混淆。

追问

  • 数量未知怎么办?答:边追加边观察,必要时二次预留,避免每次小扩容。
  • 预分配写法是什么?答:make([]T, 0, n) 保留 len=0、cap=n,后续 append 不扩容;make([]T, n) 直接填长度。

04.3.1.2-010 切片表达式的边界规则是什么?

一句话结论

s[low:high] 取索引 [low, high) 区间,low 默认 0,high 默认 cap;越界访问会在运行时 panic。

概念解释

半开区间包含 low 不包含 high。三索引表达式 s[low:high:max] 可限制新切片 cap 为 max-low,防止后续 append 写到父切片区间。

原理流程

  1. 校验 low/high 在合法范围。
  2. 生成指向 low 位置的新切片头。
  3. 越界索引触发运行时 panic。

代码或图示

b := a[1:3]    // 索引 1、2
c := a[1:3:3]  // cap 限制为 2

常见误区

  • 区间是闭区间 [low, high]:Go 是半开区间。
  • 三索引表达式改变元素内容:它只限制容量视图。

追问

  • 越界 panic 时机?答:运行时检查索引范围,编译期不能发现所有越界。
  • 三索引表达式作用?答:s[low:high:max] 把 cap 限制为 max-low,防止后续 append 越过原数组。

04.3.1.2-011 从切片删除元素有哪些方式,各有什么代价?

一句话结论

保留顺序需 copy 前移后续元素;不要求顺序可把末元素换到待删位置;删除后多余位置应清零引用,避免对象滞留。

概念解释

切片没有内置删除操作。前移删除保持顺序但有 O(n) 拷贝;交换删除 O(1) 但打乱顺序。删除后尾部指针清理防止内存滞留。

原理流程

  1. 定位待删索引 i。
  2. 顺序删除:copy 前移;无序删除:末元素填入 i。
  3. 尾部清零引用,缩短 len。

代码或图示

// 无序删除
s[i] = s[len(s)-1]
s = s[:len(s)-1]

常见误区

  • 删除后尾部旧引用不清零:大对象被已缩短切片挂住无法回收。
  • 用空切片赋值整体替换:按需选择前移/交换。

追问

  • 待确认:泛型切片工具随标准库补充,以当前版本为准。
  • 常见删除方式有哪些?答:前移覆盖(copy(s[i:], s[i+1:]))与交换到末尾再缩容;大对象需把尾部引用置 nil 助回收。

04.3.1.2-012 切片与字符串转换时发生什么?

一句话结论

[]byte(str) 复制字符串字节得到独立切片;反向 string(b) 同样拷贝;string 不可变,转换避免共享可变视图。

概念解释

字符串底层是只读字节序列。转换时分配并拷贝,保证切片修改不影响字符串。标准库提供零拷贝辅助类型(如 unsafe/特定接口),需谨慎使用。

原理流程

  1. 字符串 → []byte:分配并拷贝字节。
  2. []byte → string:拷贝生成只读字符串。
  3. 需要零拷贝时评估安全性与版本支持。

代码或图示

b := []byte("hello")
s := string(b)

常见误区

  • 认为转换零成本:常规转换有拷贝开销。
  • 通过 unsafe 共享后随意改一侧:违反字符串不可变约束。

追问

  • 待确认:零拷贝转换的安全用法按当前版本与静态检查规则评估。
  • 常规转换为何有拷贝?答:string 不可变,转换生成独立字节副本;unsafe 共享属特殊用法,需遵守不可变约束。

04.3.1.2-013 多维 slice 与二维数组有什么区别?

一句话结论

二维数组长度固定且整体复制;二维 slice 是“切片的切片”,每行长度可不同,内层切片独立分配。

概念解释

多维 slice 外层元素是内层切片头,各行可不等长;数组矩阵要求行列固定。动态不规则集合用二维 slice。

原理流程

  1. 分配外层切片。
  2. 逐个分配内层切片。
  3. 通过 m[i][j] 访问。

代码或图示

matrix := make([][]int, n)
for i := range matrix { matrix[i] = make([]int, m) }

常见误区

  • 一次性 make 二维切片:内层需单独分配。
  • 内层长度固定当成二维数组:各行可以不等长。

追问

  • 不规则行长度?答:内层 make 不同 cap 即可。
  • 多维切片怎么分配?答:先 make 外层 [][]T,再逐个 make 内层 []T;各行长度可不等。

04.3.1.2-014 什么情况下 slice 会造成内存滞留?

一句话结论

大底层数组被一个只使用小部分元素的子切片引用,整批元素无法回收;长生命周期切片持有短生命周期对象引用也会滞留。

概念解释

GC 按引用存活判断。切片头持有底层数组指针,只要头存活,整个数组存活。删除元素后尾部旧引用同样需清理。

原理流程

  1. 大数组分配后切出小子切片。
  2. 小子切片长期存活。
  3. 大数组无法回收,形成滞留。

代码或图示

header := bigData[:10] // bigData 整体被 header 引用

常见误区

  • 只看切片 len 判断占用:cap 对应的底层数组仍被持有。
  • 删除元素等于释放对象:尾部引用未清零,对象仍可达。

追问

  • 缓解手段?答:copy 出需要的小切片,清理尾部引用。
  • 典型滞留场景?答:从大数组切出小切片长期持有,或删除元素后尾部指针仍引用大对象。

04.3.1.2-015 append 链式拼接时要注意什么?

一句话结论

每次 append 接收返回切片;连续拼接时中间切片头可能扩容变化,注意共享底层与容量边界,避免覆盖相邻元素。

概念解释

在共享数组上连续 append,若 cap 足够会覆盖父切片后续位置。拼接结果应基于独立副本或确认容量边界。

原理流程

  1. 初始切片容量评估。
  2. 逐次 append 并接收返回值。
  3. 检查是否触发扩容与共享冲突。

代码或图示

var s []int
s = append(s, 1)
s = append(s, 2, 3)

常见误区

  • 链式 append 不赋值回原变量:头丢失。
  • 父切片后续空间被静默覆盖:共享数组追加要确认 cap 边界。

追问

  • 拼接多个切片?答:预分配总容量后逐个 append,减少扩容。
  • 共享数组追加风险?答:若父切片后面还有未用容量,append 可能覆盖其他切片共享的元素;需确认 cap 边界或复制。

04.3.1.2-016 如何判断切片是否为空?

一句话结论

按 len(s) == 0 判断为空;== nil 只用于区分 nil 切片,不能替代长度判断,空切片 len 为 0 但非 nil。

概念解释

业务“空”语义是没有元素,对应 len。nil 是初始化状态,序列化与判空语义不同,避免混用。

原理流程

  1. 需要判断无元素 → len 比较。
  2. 需要区分 nil/空 → 指针状态判断。
  3. 按函数约定选择返回 nil 还是空切片。

代码或图示

if len(s) == 0 { /* 空 */ }

常见误区

  • 写 if s == nil 判空:空切片会被误判非空。
  • 对外返回 nil 导致 JSON null:接口约定需要空数组时返回 make([]T, 0)。

追问

  • 待确认:序列化库对 nil/空切片的具体输出,以库文档为准。
  • 正确判空怎么写?答:if len(s) == 0;按接口约定决定返回 nil 还是空切片。

04.3.1.2-017 slice 扩容拷贝的性能影响怎么评估?

一句话结论

用 benchmark 测量 append 循环的分配次数与耗时;预分配前后对比,观察每次扩容的拷贝成本,结合 cap 估算总拷贝量。

概念解释

扩容次数与单次拷贝长度决定总成本。热路径上反复小扩容会累积可观分配;预分配后分配次数显著下降。

原理流程

  1. 写 benchmark 跑构建切片逻辑。
  2. 比较未预分配与预分配的 allocs/op 与 ns/op。
  3. 按数据量调整 cap 预留策略。

代码或图示

go test -bench=. -benchmem

常见误区

  • 只看总耗时不看分配次数:拷贝成本藏在 allocs/op 中。
  • 预分配按最坏值拉满:内存浪费需与拷贝收益权衡。

追问

  • 待确认:benchmem 输出字段含义以 Go 工具链文档为准。
  • benchmem 看什么?答:allocs/op 与 B/op;反复扩容会推高分配次数,预分配后应明显下降。

04.3.1.2-018 排查 slice 相关问题的一般思路?

一句话结论

先看是否共享底层数组导致意外改写,再检查扩容是否发生、切片头是否回传,最后排查内存滞留与越界 panic。

概念解释

slice 问题集中在共享、扩容、头副本、引用滞留四类。按现象定位到对应机制,再用最小复现验证。

原理流程

  1. 观察是否出现跨切片意外修改。
  2. 核对 append 返回值与 cap 变化。
  3. 检查尾部引用与大数组滞留,复现越界 panic。

代码或图示

共享改写 → 扩容/头回传 → 引用滞留 → 越界 panic

常见误区

  • 出问题就复制整个切片:先定位共享与扩容根因。
  • 忽略内存滞留只看功能正确性:长期运行后堆上涨。

追问

  • 待确认:当前版本 slice 实现细节,以 runtime 源码与官方文档为准。
  • 先查哪几项?答:切片头 len/cap、是否共享底层数组、append 是否接收返回值、尾部引用是否清零。
  • 待确认:当前版本 slice 实现细节,以 runtime 源码与官方文档为准。