Go语言切片slice

小信啊啊2025-12-19 22:06

一.切片

如果说数组是固定大小的储物柜，那么切片就像是一个可以随时扩展的"魔法储物柜"。它的大小是可以动态调整的，这让我们在处理不确定数量的数据时更加灵活。

slice 本质是什么？（核心原理）

在 Go 里，slice 并不存数据，它只是一个结构体：

复制代码 
type slice struct {
    ptr  *T   // 指向底层数组的某个位置
    len  int  // 当前能用的长度
    cap  int  // 从 ptr 开始，到数组末尾还能用多少
}

记住一句话：

cap 不是"我现在有多少"，而是"我最多还能用多少"

切片的创建方式

复制代码 
// 1. 直接创建
fruits := []string{"苹果", "香蕉", "橙子"}

fmt.Printf("fruits：%v\n", fruits)
// 2. 使用make函数创建
numbers := make([]int, 3, 5) // 长度为3，容量为5的切片
fmt.Printf("numbers：%v\n", numbers)
// 3. 从数组创建
arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4] // [2 3 4]
fmt.Printf("slice：%v\n", slice)

切片的三个核心概念

  1. 指针：指向底层数组的第一个可见元素
  2. 长度：切片当前的元素个数（len）
  3. 容量：从切片起始位置到底层数组末尾的元素个数（cap）
  4. 如果切片还没有用完容量，则不会分配新数组，使用的还是原数组

实用的切片操作

复制代码 
//创建一个购物清单
	shoppingList := []string{"面包"}
	//新增商品
	shoppingList = append(shoppingList, "油条")
	shoppingList = append(shoppingList, "牛奶", "玉米")
	fmt.Printf("购物清单：%v\n", shoppingList)
	fmt.Printf("清单长度：%d\n", len(shoppingList))
	fmt.Printf("清单容量：%d\n", cap(shoppingList))

	//复制切片
	backup := make([]string, len(shoppingList))
	copy(backup, shoppingList)
	fmt.Printf("备份清单：%v\n", backup)

输出：

购物清单：面包 油条 牛奶 玉米

清单长度：4

清单容量：4

备份清单：面包 油条 牛奶 玉米

切片的注意事项

  1. 切片是引用类型，多个切片可能共享同一个底层数组
  2. append可能导致重新分配内存，生成新的底层数组
  3. 使用make创建切片时，可以指定容量来减少内存重新分配的次数

二.实际应用场景对比

  1. 什么时候用数组？
    • 当你确切知道数据的长度，且不会改变时
    • 例如：存储一周七天的温度数据
  1. 什么时候用切片？
    • 处理动态数据，如用户输入的列表
    • 需要对数据进行频繁的添加和删除操作
    • 作为函数参数传递（更加灵活）

三.切片的扩容机制

理解切片的‌扩容机制就像了解一⁢个智能存储系统的工⁡作原理，这对写出高؜效的 Go 程序‎至关重要。

小容量时翻倍，大容量时缓慢增长

具体规则 ：

|-----------|---------------------|
| 当前 cap | 新 cap |
| < 1024 | cap * 2 |
| >= 1024 | cap * 1.25 （逐渐变慢） |

示例：

复制代码 
 s := make([]int, 0)
    lastCap := cap(s)

    for i := 0; i < 50; i++ {
        s = append(s, i)
        if cap(s) != lastCap {
            fmt.Printf("len=%d cap=%d\n", len(s), cap(s))
            lastCap = cap(s)
        }
    }

输出：

len=1 cap=1

len=2 cap=2

len=3 cap=4

len=5 cap=8

len=9 cap=16

len=17 cap=32

可以看出 是 典型的 2 倍增长

如果是大于1024后 将是1.25倍增长

示例：

复制代码 
s := make([]int, 0)
	lastCap := cap(s)
	fmt.Printf("初始容量：%d\n", lastCap)
	for i := 0; i < 5000; i++ {
		s = append(s, i)
		if cap(s) != lastCap {
			fmt.Printf("len=%d cap=%d\n", len(s), cap(s))
			lastCap = cap(s)
		}
	}

输出：

初始容量：0

len=1 cap=1

len=2 cap=2

len=3 cap=4

len=5 cap=8

len=9 cap=16

len=17 cap=32

len=33 cap=64

len=65 cap=128

len=129 cap=256

len=257 cap=512

len=513 cap=848

len=849 cap=1280

len=1281 cap=1792

len=1793 cap=2560

len=2561 cap=3408

len=3409 cap=5120

1.为什么 append 会"污染"别的 slice？（本质原因）

复制代码 
a := []int{1, 2, 3, 4}
b := a[:2]        // len=2 cap=4

b = append(b, 99)

因为：

  • b.cap = 4
  • append 没超 cap
  • 直接写到了 a[2]

结果：

a = 1 2 99 4

⚠️ 这是 slice 共享底层数组的必然后果

2. 如何 100% 控制 append 是否扩容

✅ 方法 1：提前 make 好 cap（最常用）
复制代码 
s := make([]int, 0, 1000)

👉 高性能，避免多次扩容

✅ 方法 2：三参数切片（防止污染）
复制代码 
b := a[:2:2] // len=2 cap=2
b = append(b, 99) // 一定扩容

面试级总结

  • append 是否扩容只看：len + n > cap
  • 不扩容：共享底层数组
  • 扩容：新数组 + 拷贝
  • 小 cap 翻倍，大 cap 缓慢增长
  • slice 之间的"诡异互相影响"，100% 来自共享底层数组

四.copy() 和 append() 有什么本质区别

一句话总纲（先背）：

append 是"扩展 slice"
copy 是"拷贝数据"

更直白一点：

  • append：我要往 slice 里加东西
  • copy：我要一个和你内容一样，但互不影响的 slice

一、最本质的区别（核心）

|-------------|--------|-----------|
| 对比点 | append | copy |
| 是否创建新元素 | ✅ | ❌ |
| 是否可能分配新数组 | ⚠️ 可能 | ❌（只写已有空间） |
| 是否解决共享底层数组 | ❌ | ✅ |
| 是否改变 len | ✅ | ❌ |
| 是否返回新 slice | ✅ | ❌（返回拷贝个数） |

一句话总结：

append 管"长度"
copy 管"内存独立性"

二、append 的本质

复制代码 
b := append(a, x)

背后逻辑：

  1. 看 cap 够不够
  2. 够 → 直接写底层数组
  3. 不够 → 新数组 + copy 旧数据 + 追加新数据

⚠️ 注意：
无法控制 append 一定扩容（除非三参数切片）

三、copy 的本质

复制代码 
n := copy(dst, src)

copy 的前提条件非常重要：

dst 必须已经有长度（len > 0）

复制代码 
dst := []int{}        // len = 0
copy(dst, src)        // 拷贝 0 个 ❌

正确姿势：

复制代码 
dst := make([]int, len(src))
copy(dst, src)

四、什么时候"必须"用 copy？（重点）

场景 1️⃣：函数里保存 slice（最常见）
复制代码 
func save(s []byte) {
    global = s // ❌ 危险
}

如果外部还会改 s，就出问题了。

✅ 正确做法：

复制代码 
func save(s []byte) {
    //创建一个切片，将切片s复制到新切片中
    buf := make([]byte, len(s))
    copy(buf, s)
    global = buf
}

📌 规则：

只要 slice 要"活得比调用者久"，就必须 copy

场景 2️⃣：从 buffer / pool / io 读数据
复制代码 
buf := make([]byte, 1024)
n, _ := conn.Read(buf)

process(buf[:n]) // ❌

buf 很可能会被复用。

✅ 正确：

复制代码 
data := make([]byte, n)
copy(data, buf[:n])
process(data)

这是 Go 网络编程铁律

场景 3️⃣：从大 slice 切小 slice（内存泄漏）
复制代码 
big := make([]byte, 10<<20) // 10MB
small := big[:100]

👉 small一直引用 10MB

✅正确：

复制代码 
small := make([]byte, 100)
copy(small, big[:100])

五.什么时候绝对不要用 copy？

❌ 情况：你只是想加元素

复制代码 
s := []int{1, 2}
copy(s, []int{3}) // ❌ 错误理解

copy 不会扩容、不会 append

六.一个对比示例（非常直观）

复制代码 
a := []int{1, 2, 3}
	b := a[:2]
	c := make([]int, 3)
	copy(c, a[:2])
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	b[0] = 100 //由于是共享数组 会改变a的值
	c[1] = 200 //copy后，是独立的 不会改变a的值
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)

👉 b 共享

👉 c 独立

输出：

1 2 3

1 2

1 2 0

100 2 3

100 2

[1 200 0

七. 工程级判断口诀

看到 slice → 问三件事：

1️⃣ 我会不会 append？

2️⃣ 会不会跨函数 / goroutine 使用？

3️⃣ 原 slice 会不会再被改？

只要有一个是"是" → 用 copy

五.预分配优化策略

复制代码 
func SliceDemo11() {
	fmt.Println("=== 算法导航性能优化实验 ===")

	const dataSize = 10000000

	// 测试1：不预分配容量
	start := time.Now()
	var slice1 []int
	for i := 0; i < dataSize; i++ {
		slice1 = append(slice1, i)
	}
	duration1 := time.Since(start)

	// 测试2：预分配足够容量
	start = time.Now()
	slice2 := make([]int, 0, dataSize)
	for i := 0; i < dataSize; i++ {
		slice2 = append(slice2, i)
	}
	duration2 := time.Since(start)

	// 测试3：预分配长度并直接赋值
	start = time.Now()
	slice3 := make([]int, dataSize)
	for i := 0; i < dataSize; i++ {
		slice3[i] = i
	}
	duration3 := time.Since(start)

	fmt.Printf("处理 %d 个元素的性能对比:\n", dataSize)
	fmt.Printf("不预分配:   %v\n", duration1)
	fmt.Printf("预分配容量: %v (提升 %.2fx)\n", duration2,
		float64(duration1)/float64(duration2))
	fmt.Printf("预分配长度: %v (提升 %.2fx)\n", duration3,
		float64(duration1)/float64(duration3))

	// 实际应用建议
	fmt.Println("\n=== 实际应用建议 ===")

	// 示例：编程导航用户数据处理
	expectedUserCount := 10000

	// 好的做法：预分配容量
	users := make([]map[string]interface{}, 0, expectedUserCount)
	fmt.Printf("预分配用户切片容量: %d\n", cap(users))

	// 模拟添加用户数据
	for i := 0; i < 5; i++ {
		user := map[string]interface{}{
			"id":    i + 1,
			"name":  fmt.Sprintf("user%d", i+1),
			"level": i%3 + 1,
		}
		users = append(users, user)
	}

	fmt.Printf("添加5个用户后: 长度=%d, 容量=%d\n", len(users), cap(users))
	fmt.Println("✅ 没有发生扩容，性能最优")
}

输出：

=== 算法导航性能优化实验 ===

处理 10000000 个元素的性能对比:

不预分配: 116.2406ms

预分配容量: 17.4931ms (提升 6.64x)

预分配长度: 19.9891ms (提升 5.82x)

=== 实际应用建议 ===

预分配用户切片容量: 10000

添加5个用户后: 长度=5, 容量=10000

✅ 没有发生扩容，性能最

从上面的输出可得知，预分配的性能比不预分配性能好很多

相关推荐
AskHarries4 分钟前
Browser Tool：网页打开、点击、输入、截图和验证
后端
一线大码15 分钟前
Smart-Doc 的简单使用
java·后端·restful
喵个咪28 分钟前
技术复盘：基于 go-wind-cms 的官网+商城双业务渐进拆分实战
后端·架构·go
ZengLiangYi40 分钟前
批量导入 1000 条对话的性能优化实战
javascript·后端·架构
juejin9981 小时前
Claude Code 环境跑通：第一次有效对话
后端
wei_shuo1 小时前
KES 数据库迁移实战：从 Oracle/MySQL 到 KingbaseES 的平滑过渡指南
后端
长栎1 小时前
Lombok @Builder 越用越爽，直到生产上构造函数的参数顺序全乱了
后端
长栎1 小时前
Spring 的 prototype scope 你用对了吗？原型模式的三个正确打开方式
后端
XovH1 小时前
MySQL 系列：第13篇 索引，不止是目录
后端
云技纵横1 小时前
Gap Lock 死锁实战：5 秒在本地复现 MySQL 间隙锁死锁
后端·mysql
热门推荐
012026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？022026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf03【AI】2026 年具身智能模型和世界模型总结042026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？052026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？06GitHub 镜像站点07AI科技热点日报 | 2026年6月1日08上线仅72小时被强制下架：Claude Fable 5 的短命09HTTP 与 HTTPS 的区别：从原理到实战详解10Codex 下载安装指南：Windows 和 macOS 官方版下载