一、切片核心概念

1. 本质：对底层数组的引用，不是值类型，是引用类型
2. 作用：弥补数组长度固定的缺陷，实现动态变长数组
3. 定义：声明时不指定长度，格式[]T（T 为元素类型）

二、切片的创建方式（4 种常用）

1. 从数组 / 切片截取（最基础）

语法：切片名 := 源数组/切片[low:high:max]

• low：起始下标（包含），默认 0
• high：结束下标（不包含，左闭右开），默认末尾
• max：容量上限，默认等于底层数组容量
• 长度公式：len = high - low
• 容量公式：cap = max - low

go

// 示例 array := [...]int{10, 20, 30, 0, 0} // 固定长度数组 slice := array[0:3:5] // len=3-0=3，cap=5-0=5，元素：[10,20,30]

2. 自动推导类型创建

go

// 直接初始化切片，长度=元素个数，容量=长度 s1 := []int{1, 2, 3, 4, 5}

3. make 函数创建（开发最常用）

语法：make([]T, len, cap)

• 不指定容量：cap = len
• 必须指定长度，容量≥长度

go

s2 := make([]int, 5, 10) // len=5，cap=10 s3 := make([]int, 5) // 无容量，len=cap=5 s4 := []int{} // 空切片，len=0，cap=0

三、切片的长度 (len) 和容量 (cap)

• 长度 (len)：切片中实际存储的元素个数
• 容量 (cap)：底层数组从起始位置到末尾的最大可存储元素个数（决定扩容时机）

go

func main() { a := []int{1, 2, 3, 0, 0} s := a[0:3:5] fmt.Println("len(s) =", len(s)) // 3 fmt.Println("cap(s) =", cap(s)) // 5 s2 := a[1:4:5] fmt.Println("len(s2) =", len(s2)) // 3 (4-1) fmt.Println("cap(s2) =", cap(s2)) // 4 (5-1) }

四、切片截取操作（常用简写）

go

array := []int{0,1,2,3,4,5,6} s1 := array[:] // 全量截取：low=0,high=len,cap=cap s2 := array[3:6] // 不写max：cap=底层数组容量 s3 := array[:6] // 从0开始到下标6，最常用 s4 := array[3:] // 从下标3开始到末尾

五、切片与底层数组的关系（核心重点）

切片共享底层数组，修改切片元素会直接修改原数组 / 其他切片，属于引用传递。

go

func main() { a := []int{0,1,2,3,4,5,6,7,8,9} s1 := a[2:5] // [2,3,4]，引用a数组 // 修改切片元素 → 原数组同步修改 s1[1] = 666 fmt.Println("s1 =", s1) // [2,666,4] fmt.Println("a =", a) // 原数组下标3变为666 // 切片再截取 → 仍共享底层数组 s2 := s1[2:7] // [4,5,6,7,8] s2[2] = 777 fmt.Println("a =", a) // 原数组下标6变为777 }

六、append () 追加元素（动态扩容）

append是切片动态扩容的核心函数，超出容量时自动扩容。

1. 基础用法

go

s1 := []int{} // 空切片 s1 = append(s1, 1) // 追加单个元素 s1 = append(s1, 2, 3) // 追加多个元素

2. 扩容规则

• 容量不足时，默认以 2 倍容量扩容（小切片）
• 扩容后会新建底层数组，不再与原数组共享

go

// 验证扩容机制 func main() { s := make([]int, 0, 1) oldCap := cap(s) for i := 0; i < 8; i++ { s = append(s, i) if newCap := cap(s); oldCap < newCap { fmt.Printf("cap: %d ===> %d\n", oldCap, newCap) oldCap = newCap } } } /* 输出： cap: 1 ===> 2 cap: 2 ===> 4 cap: 4 ===> 8 */

七、copy () 切片复制

解决切片共享底层数组的问题，深拷贝，两个切片完全独立。

go

func main() { srcSlice := []int{1, 2} // 源切片 dstSlice := []int{6,6,6,6} // 目标切片 copy(dstSlice, srcSlice) // 复制：将源切片元素拷贝到目标切片 fmt.Println("dst =", dstSlice) // [1,2,6,6] }

八、切片作为函数参数

切片是引用类型，函数内修改切片，外部原切片同步修改（无需指针）。

实战：切片初始化 + 冒泡排序

go

import ( "math/rand" "time" ) // 初始化切片：随机数赋值 func InitData(s []int) { rand.Seed(time.Now().UnixNano()) for i := 0; i < len(s); i++ { s[i] = rand.Intn(100) // 0-99随机数 } } // 冒泡排序：切片做参数，直接修改原切片 func BubbleSort(s []int) { n := len(s) for i := 0; i < n-1; i++ { for j := 0; j < n-i-1; j++ { if s[j] > s[j+1] { s[j], s[j+1] = s[j+1], s[j] // 交换元素 } } } } func main() { // 创建切片 s := make([]int, 10) InitData(s) fmt.Println("排序前：", s) BubbleSort(s) fmt.Println("排序后：", s) }

九、核心易错点总结

1. 切片不存储数据，底层依赖数组，是引用类型
2. [low:high]是左闭右开，不包含 high 下标元素
3. len=high-low，cap=max-low
4. append扩容后会新建底层数组，断开与原数组的关联
5. 切片做函数参数，传引用，修改会影响原切片
6. copy可以实现切片深拷贝，避免共享数组

总结

1. 切片是 Go 的动态数组，专门解决数组长度固定的痛点，开发优先用切片
2. 核心操作：截取、append扩容、copy拷贝、函数传参
3. 核心原理：引用底层数组，扩容机制是 2 倍扩容
4. 实战中：优先用make创建切片，用append动态添加元素