maps.Clone 后修改嵌套值为何影响原 map

maps.Clone 后修改嵌套值会影响原 map，是因为它执行的是浅拷贝。新 map 的顶层容器确实独立，但每个键和值只是通过普通赋值复制；当值是切片、指针、内层 map，或含有这些字段的结构体时，副本仍可能指向原来的底层数据。

官方文档：https://pkg.go.dev/maps

判断副本是否独立，不要只看“外层 map 是否新建”，还要看值里面有没有可变的引用型数据。基础值和数组通常可直接 Clone；切片、map、指针等需要按业务所有权逐层复制。

先复现：顶层改动独立，切片元素却会联动

下面的例子同时修改顶层键和切片元素。前者只影响克隆 map，后者会通过共享的底层数组回写到原数据。

package main

import (
	"fmt"
	"maps"
)

func main() {
	original := map[string][]string{
		"labels": {"go", "backend"},
	}
	cloned := maps.Clone(original)

	// 替换整个键值只修改克隆 map 的顶层槽位
	cloned["extra"] = []string{"new"}

	// 修改切片元素会写入共享底层数组，原 map 也能看到
	cloned["labels"][0] = "golang"

	fmt.Println(original["labels"]) // [golang backend]
	fmt.Println(cloned["extra"])   // [new]
}

看起来矛盾的两个结果，实际来自不同层级：cloned 是一个新 map，所以增加或删除顶层键不会改变 original；但 labels 的值是切片描述符，普通赋值后仍引用同一块底层数组。

根因：Clone 只复制顶层键和值

Go 官方文档对 maps.Clone 的描述很直接：它是 shallow clone，新键和值使用普通赋值设置。普通赋值会完整复制整数、字符串、布尔值、数组这类值本身；对于切片、map、指针等值，复制的是引用信息，不会递归复制它们指向的内容。

可以把 Clone 理解成把原 map 的每个键值对重新放进一个新 map：

func shallowClone[K comparable, V any](src map[K]V) map[K]V {
	dst := make(map[K]V, len(src))
	for key, value := range src {
		// 普通赋值只复制当前这一层的 value
		dst[key] = value
	}
	return dst
}

这正是 maps.Clone 的语义重点。函数不可能仅凭泛型参数 V any 猜出每种业务类型应如何深拷贝，也无法判断某个指针是应该共享、复制，还是保持身份唯一。

哪些值会独立，哪些值仍然共享

还有一个容易忽略的点：对切片执行 append 时，是否影响原值取决于容量。如果副本切片还有空余容量，追加可能继续写共享数组；如果触发扩容，它会获得新数组。不能把一次“看起来没影响”的 append 当作已经深拷贝。

切片值怎么复制才真正隔离

对于 map[string][]string，最清晰的做法是新建外层 map，再为每个切片创建新底层数组。Go 可以用 slices.Clone 表达这层意图。

package config

import "slices"

func cloneStringSlices(src map[string][]string) map[string][]string {
	dst := make(map[string][]string, len(src))
	for key, values := range src {
		// 为每个切片复制底层数组，阻断元素修改的共享关系
		dst[key] = slices.Clone(values)
	}
	return dst
}

如果项目需要兼容不使用 slices.Clone 的环境，也可以使用 append([]T(nil), src...) 或 make + copy。关键不是函数名，而是确保目标切片拥有独立的底层存储。

func copyInts(src []int) []int {
	if src == nil {
		// 保留 nil 与空切片在业务语义上的区别
		return nil
	}
	dst := make([]int, len(src))
	copy(dst, src) // 复制每个元素到新的底层数组
	return dst
}

内层 map 和指针值要分别处理

嵌套 map 可以对每个内层 map 再调用一次 maps.Clone。如果内层值仍是切片或指针，则还要继续向下复制，直到到达希望隔离的层级。

package config

import "maps"

func cloneNested(src map[string]map[string]int) map[string]map[string]int {
	dst := make(map[string]map[string]int, len(src))
	for key, inner := range src {
		// 内层值都是 int，因此再 Clone 一层即可完成隔离
		dst[key] = maps.Clone(inner)
	}
	return dst
}

指针结构更适合给业务类型定义自己的 Clone 方法。这样可以明确哪些字段深拷贝，哪些只读对象允许共享。

type Profile struct {
	Name  string
	Roles []string
}

func (p *Profile) Clone() *Profile {
	if p == nil {
		// nil 指针保持 nil，避免制造不存在的对象
		return nil
	}
	copyProfile := *p
	// 结构体赋值后，仍需复制其中的切片字段
	copyProfile.Roles = append([]string(nil), p.Roles...)
	return ©Profile
}

func cloneProfiles(src map[string]*Profile) map[string]*Profile {
	dst := make(map[string]*Profile, len(src))
	for key, profile := range src {
		dst[key] = profile.Clone() // 每个指针值获得独立对象
	}
	return dst
}

什么时候浅拷贝反而更合适

深拷贝不是越多越安全。它会增加分配、复制时间和内存占用，还可能破坏某些对象刻意保持的身份关系。下面几种场景，maps.Clone 的浅拷贝反而足够：

• 值是基础类型、数组或只含基础字段的结构体；
• 嵌套对象在创建后只读，不会被任何一方修改；
• 业务本来就要求多个视图共享同一对象；
• 只想独立增删顶层键，不打算修改嵌套内容。

需要深拷贝的典型信号是：副本会被独立修改、会跨 goroutine 传递给不同所有者，或者要作为快照长期保存。即使完成深拷贝，并发读写同一份剩余共享对象仍需要同步；Clone 本身不提供并发安全。

用测试锁定“副本不会回写”

深拷贝函数最值得测试的不是两个值刚复制完时是否相等，而是修改副本后原数据是否保持不变。

func TestCloneStringSlicesIsIndependent(t *testing.T) {
	original := map[string][]string{
		"labels": {"go", "backend"},
	}
	cloned := cloneStringSlices(original)

	// 修改副本的嵌套元素，验证原切片没有被回写
	cloned["labels"][0] = "golang"
	if original["labels"][0] != "go" {
		t.Fatalf("原数据被副本修改: %v", original["labels"])
	}
}

如果数据结构以后新增了切片、map 或指针字段，这类测试会及时提醒你同步更新 Clone 逻辑。相比依赖反射或序列化做通用深拷贝，显式复制通常更快、更容易控制 nil、不可导出字段和共享对象的语义。

常见问题

maps.Copy 会比 maps.Clone 更深吗？

不会。maps.Copy 同样把源 map 的键和值通过普通赋值写入目标 map，嵌套引用值仍可能共享。

map 的值是结构体就一定安全吗？

不一定。只含数字、字符串等值字段时通常独立；如果结构体内含切片、map 或指针，这些字段仍可能共享底层对象。

用 JSON 序列化再反序列化能深拷贝吗？

某些纯数据结构可以，但会有额外开销，也可能丢失不受 JSON 支持的类型、字段可见性和精确语义。核心业务类型更适合显式 Clone。

为什么修改克隆 map 的顶层键不会影响原 map？

因为 maps.Clone 确实创建了新的顶层 map。共享发生在嵌套引用值指向的对象，而不是外层 map 容器本身。

所以，maps.Clone 没有失效，它只是严格遵守浅拷贝语义。先确认值类型中的可变引用层级，再决定复制到哪里；把所有权边界写进专用 Clone 函数和测试，才能真正避免副本修改回写原 map。