6.1 Go 切片学习笔记1. 切片基础 — 创建与共享底层数组切片是 Go 中最核心的数据结构它是动态数组的视图由指针、长度、容量三部分组成packagemainimportfmtfuncmain(){// 从数组创建切片arr[low:high]包含 low 到 high-1 的元素arr:[5]int{1,2,3,4,5}slice1:arr[1:4]// [2, 3, 4]// make() 创建切片make([]type, length, capacity)slice2:make([]string,3,5)// 长度3容量5元素为string零值// 长度3已有3个元素可访问容量5底层数组可容纳5个元素// 切片字面量直接声明与数组字面量不同没有长度slice3:[]int{10,20,30}// 切片不是数组没有 [N]// nil 切片var 声明未初始化varslice4[]int// slice4 nillen0, cap0ifslice4nil{fmt.Println(slice4 is nil)}// len() 和 cap() 获取长度和容量length:len(slice2)capacity:cap(slice2)// 修改切片元素会影响原数组共享底层内存slice1[1]99// arr[2] 也变成 99fmt.Println(Original array:,arr)fmt.Println(slice1:,slice1)fmt.Println(slice2:,slice2)fmt.Println(slice3:,slice3)fmt.Printf(slice2 - length: %d, capacity: %d\n,length,capacity)}执行结果slice4 is nil Original array: [1 2 99 4 5] slice1: [2 99 4] slice2: [ ] slice3: [10 20 30] slice2 - length: 3, capacity: 5要点切片 ≠ 数组数组有固定长度[5]int切片没有固定长度[]intarr[1:4]— 从数组创建切片包含索引 1 到 3 的元素不含索引4slice1[1] 99修改了切片元素原数组arr[2]也变成 99 —切片和数组共享底层内存make([]string, 3, 5)— 创建长度3、容量5的切片前3个元素为零值 “”还有2个预留空间[]int{10, 20, 30}— 切片字面量没有长度数字Go 自动创建底层数组var slice4 []int— nil 切片可以 nil判断与空切片[]int{}不同空切片 ! nilslice2 输出[ ]— 3个空字符串string 的零值是 “”2. append — 追加元素与容量增长append()向切片追加元素超过容量时自动扩容packagemainimportfmtfuncmain(){// 从 nil 切片开始 append完全合法varnumbers[]intnumbersappend(numbers,1)// 追加单个元素numbersappend(numbers,2,3,4)// 追加多个元素// 用 ... 展开切片追加moreNumbers:[]int{5,6,7}numbersappend(numbers,moreNumbers...)// 展开追加// 观察容量增长make([]string, 0, 2)fruits:make([]string,0,2)// 长度0容量2fmt.Printf(Initial - len: %d, cap: %d\n,len(fruits),cap(fruits))fruitsappend(fruits,apple)fmt.Printf(After 1 append - len: %d, cap: %d\n,len(fruits),cap(fruits))fruitsappend(fruits,banana)fmt.Printf(After 2 appends - len: %d, cap: %d\n,len(fruits),cap(fruits))// 第3次 append 超出容量触发扩容2 → 4fruitsappend(fruits,cherry)fmt.Printf(After 3 appends - len: %d, cap: %d\n,len(fruits),cap(fruits))// nil 切片可以直接 appendvarcolors[]string// nil 切片colorsappend(colors,red)// append 自动分配底层数组fmt.Println(Numbers:,numbers)fmt.Println(Fruits:,fruits)fmt.Println(Colors:,colors)}执行结果Initial - len: 0, cap: 2 After 1 append - len: 1, cap: 2 After 2 appends - len: 2, cap: 2 After 3 appends - len: 3, cap: 4 Numbers: [1 2 3 4 5 6 7] Fruits: [apple banana cherry] Colors: [red]要点append(slice, element)— 返回新切片长度1必须用接住返回值numbersappend(numbers,1)// 必须赋值append 可能返回新底层数组append(numbers, 2, 3, 4)— 同时追加多个元素append(numbers, moreNumbers...)— 用...展开切片追加容量增长过程Initial: len0, cap2预留2个位置append “apple”: len1, cap2还剩1个位置append “banana”: len2, cap2满了append “cherry”: len3, cap4超出容量扩容到4— 容量翻倍nil 切片可以 appendGo 自动分配底层数组无需 make 初始化扩容策略通常翻倍2→4→8→16…但 Go 运行时可能根据情况调整3. 浅拷贝与深拷贝 — copy()切片的拷贝有浅拷贝共享底层数组和深拷贝独立底层数组两种packagemainimportfmtfuncmain(){original:[]int{1,2,3,4,5}// 浅拷贝original[:] 创建新切片头但共享底层数组shallow:original[:]shallow[0]999// 修改 shallow 也修改 originalfmt.Println(After modifying shallow copy:)fmt.Println(Original:,original)// [999 2 3 4 5] — 被修改了fmt.Println(Shallow:,shallow)// [999 2 3 4 5]// 重置 originaloriginal[0]1// 深拷贝copy() 创建独立底层数组deep:make([]int,len(original))// 先创建目标切片copy(deep,original)// copy(dest, src) — 复制元素deep[0]888// 修改 deep 不影响 originalfmt.Println(\nAfter modifying deep copy:)fmt.Println(Original:,original)// [1 2 3 4 5] — 未被修改fmt.Println(Deep:,deep)// [888 2 3 4 5]// copy 返回复制的元素数量source:[]string{a,b,c,d,e}destination:make([]string,3)// 目标长度3copied:copy(destination,source)// 只能复制3个目标容量限制fmt.Printf(\nCopied %d elements: %v\n,copied,destination)// 小切片复制到大切片small:[]int{100,200}large:make([]int,5)n:copy(large,small)// 只复制2个剩余3个保持零值0fmt.Printf(Copied %d elements to large slice: %v\n,n,large)}执行结果After modifying shallow copy: Original: [999 2 3 4 5] Shallow: [999 2 3 4 5] After modifying deep copy: Original: [1 2 3 4 5] Deep: [888 2 3 4 5] Copied 3 elements: [a b c] Copied 2 elements to large slice: [100 200 0 0 0]要点浅拷贝original[:]— 新切片头 共享底层数组修改互相影响深拷贝copy(dest, src)— 创建独立底层数组修改互不影响步骤先make([]int, len)创建目标 → 再copy(dest, src)复制元素copy(dest, src)返回实际复制的元素数 min(len(dest), len(src))目标长度3源长度5只复制3个 →[a b c]源长度2目标长度5复制2个剩余保持零值 →[100 200 0 0 0]copy不会扩容目标切片目标切片必须预先make并有足够长度4. 切片容量与底层共享 — 深入理解切片容量是从切片起始位置到底层数组末尾的元素数量理解容量是理解切片的关键packagemainimportfmtfuncmain(){// make 指定长度和容量slice1:make([]int,5,10)// 5个零值元素底层数组容量10fmt.Printf(slice1 - len: %d, cap: %d, slice: %v\n,len(slice1),cap(slice1),slice1)fori:rangeslice1{slice1[i]i*2}fmt.Printf(After filling: %v\n,slice1)// 从数组切片容量 底层数组从起始位置到末尾的长度array:[10]int{1,2,3,4,5,6,7,8,9,10}slice2:array[2:6]// 索引2到5长度4// 容量 10 - 2 8从索引2到数组末尾fmt.Printf(slice2 - len: %d, cap: %d, slice: %v\n,len(slice2),cap(slice2),slice2)// 修改切片会影响原数组slice2[0]999// array[2] 也变成 999fmt.Printf(Array after modifying slice2: %v\n,array)fmt.Printf(slice2 after modification: %v\n,slice2)// append 超出容量时触发扩容smallSlice:make([]int,2,3)// 长度2容量3fmt.Printf(Initial smallSlice - len: %d, cap: %d\n,len(smallSlice),cap(smallSlice))smallSlice[0]10smallSlice[1]20fmt.Println(Appending elements and observing capacity:)// 第1次 append还在容量内smallSliceappend(smallSlice,30)fmt.Printf(After append(30) - len: %d, cap: %d, slice: %v\n,len(smallSlice),cap(smallSlice),smallSlice)// 第2次 append超出容量扩容 3→6smallSliceappend(smallSlice,40)fmt.Printf(After append(40) - len: %d, cap: %d, slice: %v\n,len(smallSlice),cap(smallSlice),smallSlice)// 第3次 append 多个元素7个 容量6扩容 6→12smallSliceappend(smallSlice,50,60,70)fmt.Printf(After append(50,60,70) - len: %d, cap: %d, slice: %v\n,len(smallSlice),cap(smallSlice),smallSlice)}执行结果slice1 - len: 5, cap: 10, slice: [0 0 0 0 0] After filling: [0 2 4 6 8] slice2 - len: 4, cap: 8, slice: [3 4 5 6] Array after modifying slice2: [1 2 999 4 5 6 7 8 9 10] slice2 after modification: [999 4 5 6] Initial smallSlice - len: 2, cap: 3 Appending elements and observing capacity: After append(30) - len: 3, cap: 3, slice: [10 20 30] After append(40) - len: 4, cap: 6, slice: [10 20 30 40] After append(50,60,70) - len: 7, cap: 12, slice: [10 20 30 40 50 60 70]要点make([]int, 5, 10)— 长度5可访问5个元素容量10底层数组有10个位置array[2:6]的容量 10-2 8 — 从索引2到数组末尾索引0-9还有8个位置可用slice2[0] 999→array[2] 999— 切片与数组共享内存append 扩容过程append(30)len 2→3, cap 3刚好满了append(40)len 3→4, cap 3→6超出容量分配新底层数组容量翻倍append(50,60,70)len 4→7, cap 6→12再次超出容量翻倍关键扩容时分配新底层数组切片不再与原数组共享内存5. 切片重叠与完整切片表达式[low:high:max]多个切片可以共享同一底层数组修改重叠区域会互相影响完整切片表达式可以限制容量packagemainimportfmtfuncmain(){base:[]int{1,2,3,4,5,6,7,8}slice3:base[1:4]// [2, 3, 4]容量 8-1 7slice4:base[3:6]// [4, 5, 6]容量 8-3 5fmt.Printf(base: %v\n,base)fmt.Printf(slice3 [1:4]: %v (len: %d, cap: %d)\n,slice3,len(slice3),cap(slice3))fmt.Printf(slice4 [3:6]: %v (len: %d, cap: %d)\n,slice4,len(slice4),cap(slice4))// slice3[2] 对应 base[3]slice4[0] 也对应 base[3] — 重叠slice3[2]999// base[3] 变成 999slice4[0] 也变成 999fmt.Printf(After modifying slice3[2] to 999:\n)fmt.Printf(base: %v\n,base)// [1 2 3 999 5 6 7 8]fmt.Printf(slice3: %v\n,slice3)// [2 3 999]fmt.Printf(slice4: %v\n,slice4)// [999 5 6] — 被影响了// 完整切片表达式[low:high:max]max 限制容量fullSlice:base[1:4:5]// len 4-1 3, cap 5-1 4fmt.Printf(Full slice expression [1:4:5] - len: %d, cap: %d, slice: %v\n,len(fullSlice),cap(fullSlice),fullSlice)}执行结果base: [1 2 3 4 5 6 7 8] slice3 [1:4]: [2 3 4] (len: 3, cap: 7) slice4 [3:6]: [4 5 6] (len: 3, cap: 5) After modifying slice3[2] to 999: base: [1 2 3 999 5 6 7 8] slice3: [2 3 999] slice4: [999 5 6] Full slice expression [1:4:5] - len: 3, cap: 4, slice: [2 3 999]要点base[1:4]容量 7从 base 索引1到末尾8-17base[3:6]容量 5从 base 索引3到末尾8-35slice3[2] 和 slice4[0] 都指向 base[3] —重叠区域修改一个另一个也变base[1:4:5]— 完整切片表达式3索引max5限制容量 5-1 4没有第三个索引时容量到底层数组末尾7有第三个索引时容量被限制为 max-low4更安全好处append 不会侵入其他切片的区域超出限制容量时会分配新底层数组6. 扩容策略观察 — 容量增长规律观察 append 时容量的实际增长packagemainimportfmtfuncmain(){fmt.Println(Demonstrating memory reallocation:)growSlice:[]int{1}// len1, cap1fori:0;i5;i{fmt.Printf(Before append - len: %d, cap: %d\n,len(growSlice),cap(growSlice))growSliceappend(growSlice,i)fmt.Printf(After append - len: %d, cap: %d\n,len(growSlice),cap(growSlice))fmt.Println()}}执行结果Demonstrating memory reallocation: Before append - len: 1, cap: 1 After append - len: 2, cap: 2 Before append - len: 2, cap: 2 After append - len: 3, cap: 4 Before append - len: 3, cap: 4 After append - len: 4, cap: 4 Before append - len: 4, cap: 4 After append - len: 5, cap: 8 Before append - len: 5, cap: 8 After append - len: 6, cap: 8要点扩容规律1 → 2 → 4 → 8 → …大致翻倍容量4时 append 1个元素len 从3→4不需要扩容还在容量内容量4时再 appendlen 从4→5超出容量扩容到8详细过程cap1, append: len 1→2, cap 1→2翻倍cap2, append: len 2→3, cap 2→4翻倍cap4, append: len 3→4, cap 不变容量够用cap4, append: len 4→5, cap 4→8翻倍cap8, append: len 5→6, cap 不变容量够用扩容时 Go 分配新底层数组拷贝旧数据到新数组旧数组由 GC 回收性能提示如果知道大致需要多少元素用make([]T, 0, n)预分配容量避免反复扩容知识点总结知识点关键概念切片创建数组切片arr[1:4]、make([]T, len, cap)、字面量[]int{...}、nil 切片共享底层数组切片修改会影响原数组这是切片的核心特性也是常见 bug 来源append 追加返回新切片必须接住超出容量自动扩容nil 切片可以 append浅拷贝 vs 深拷贝[:]共享底层 vscopy()独立底层copy 函数copy(dest, src)返回复制数量 min(len(dest), len(src))容量计算arr[low:high]的 cap len(array) - low重叠切片同底层数组的多个切片有重叠区域修改互相影响完整切片表达式[low:high:max]限制容量防止 append 侵入其他切片扩容策略大致翻倍1→2→4→8…预分配容量可避免频繁扩容