深入 Go 语言核心：map 和 slice 的传参有什么不同
在 Go 开发中，经常会遇到需要在函数中修改 map 或 slice 的场景。虽然它们都支持动态扩容，但在函数传参时的行为却大不相同。今天，让我们通过实例深入理解这个问题。
一个困惑的开始
看这样一个例子：
func main() {
// Map 示例
m := map[string]int{"old": 1}
modifyMap(m)
fmt.Println(m) // 输出: map[new:1]
// Slice 示例
s := []int{1, 2, 3}
modifySlice(s)
fmt.Println(s) // 输出: [100 2 3]，而不是 [100 2 3 200]
}
func modifyMap(m map[string]int) {
m["new"] = 1 // 会影响原始 map
delete(m, "old") // 也会影响原始 map
}
func modifySlice(s []int) {
s[0] = 100 // 会影响原始 slice
s = append(s, 200) // 不会影响原始 slice
}
有趣的是：
- map 的所有操作都会影响原始数据
- slice 的简单索引修改会影响原始数据，但 append 可能不会
为什么会这样？让我们从内部结构开始分析。
内部结构解析
Map 的内部结构
type hmap struct {
count int // 元素个数
flags uint8 // 状态标志
B uint8 // 桶的对数 B
buckets unsafe.Pointer // 指向桶数组的指针
// ... 其他字段
}
当我们声明一个 map 变量时：
m := make(map[string]int)
// 实际上 m 是 *hmap，即指向 hmap 结构的指针
Slice 的内部结构
type slice struct {
array unsafe.Pointer // 指向底层数组的指针
len int // 当前长度
cap int // 当前容量
}
当我们声明一个 slice 变量时：
s := make([]int, 0, 10)
// s 是一个完整的 slice 结构体，而不是指针
深入理解传参行为
场景一：简单修改（不涉及扩容）
func modifyBoth(m map[string]int, s []int) {
m["key"] = 1 // 通过指针修改原始 map
s[0] = 100 // 通过指向相同底层数组的指针修改
}
图解：
Map:
main()中的 m -----> hmap{...} <----- modifyBoth()中的 m
(同一个底层结构)
Slice:
main()中的 s = slice{array: 指向数组1, len: 3, cap: 3}
|
v
[1 2 3]
^
modifyBoth()中的 s = slice{array: 指向数组1, len: 3, cap: 3}
场景二：涉及扩容的操作
func expandBoth(m map[string]int, s []int) {
// map 扩容
for i := 0; i < 100; i++ {
m[fmt.Sprintf("key%d", i)] = i
}
// slice 扩容
s = append(s, 200)
}
图解：
Map 扩容过程：
Before:
main()中的 m -----> hmap{buckets: 指向存储A}
^
expandBoth()中的 m ---------|
After:
main()中的 m -----> hmap{buckets: 指向更大的存储B} // 同一个 hmap，只是更新了内部指针
^
expandBoth()中的 m ---------|
Slice 扩容过程：
Before:
main()中的 s = slice{array: 指向数组A, len: 3, cap: 3}
|
v
[1 2 3]
^
expandBoth()中的 s = slice{array: 指向数组A, len: 3, cap: 3}
After append:
main()中的 s = slice{array: 指向数组A, len: 3, cap: 3} // 保持不变
|
v
[1 2 3]
expandBoth()中的 s = slice{array: 指向数组B, len: 4, cap: 6} // 新的结构体，指向新数组
|
v
[1 2 3 200]
关键区别解析
-
传递方式不同：
- map 传递的是指针，函数内外使用的是同一个 hmap 结构
- slice 传递的是结构体副本，函数内的修改发生在副本上
-
扩容行为不同：
- map 扩容时，原有的 hmap 结构保持不变，只更新内部的 buckets 指针
- slice 扩容时，会创建新的底层数组，并返回一个指向新数组的新 slice 结构体
-
修改效果不同：
- map 的所有操作（包括扩容）都会反映到原始数据
- slice 的行为分两种情况：
- 不涉及扩容的修改会影响原始数据（因为指向同一个底层数组）
- 涉及扩容的操作（如 append）会创建新的底层数组，修改不会影响原始数据
最佳实践
基于以上原理，在编码时应注意：
- 对于 map：
func modifyMap(m map[string]int) {
m["key"] = 1 // 直接修改即可，不需要返回
}
- 对于 slice：
func modifySlice(s []int) []int {
// 如果需要 append 或其他可能导致扩容的操作
return append(s, 1)
}
// 使用时
s = modifySlice(s)
总结
理解 map 和 slice 的这些差异，关键在于：
- map 是指针类型，始终指向同一个 hmap 结构
- slice 是结构体，包含了指向底层数组的指针
- 扩容时 map 只更新内部指针，而 slice 需要创建新的底层数组
这种设计各有优势：
- map 的行为更加统一和直观
- slice 的设计提供了更多的灵活性和控制权
在实际编程中，正确理解和处理这些差异，是写出健壮 Go 代码的关键。