Go语言通过反射实现通用深拷贝，递归处理指针、切片、映射、结构体等类型，跳过不可导出字段，确保内存独立且避免循环引用。
Go 语言本身不支持直接的深拷贝语法，但通过反射（reflect）可以实现通用、类型安全的结构体深拷贝。关键在于递归处理指针、切片、映射、嵌套结构体等复合类型，同时避免循环引用导致的无限递归。
核心思路：用反射遍历并重建值
深拷贝的本质是创建一个与原对象内容相同、但内存地址完全独立的新对象。反射允许我们在运行时检查任意类型的字段、类型和值，并逐层复制：
- 对基本类型（int、string、bool 等），直接赋值即可
- 对指针，需解引用后复制目标值，再新建指针指向新副本
- 对 slice，需新建底层数组，逐项递归拷贝元素
- 对 map，需新建 map，递归拷贝每个 key 和 value
- 对 struct，遍历所有可导出字段（仅导出字段可被反射读写），递归拷贝每个字段值
- 对 interface{}，先判断其实际类型，再按对应逻辑处理
一个简洁可靠的深拷贝函数实现
以下是一个生产可用的通用深拷贝函数，支持嵌套结构体、指针、slice、map、interface{}，并自动跳过不可导出字段：
func DeepCopy(src interface{}) interface{} {
v := reflect.ValueOf(src)
if !v.IsValid() {
return nil
}
return deepCopyValue(v).Interface()
}
func deepCopyValue(v reflect.Value) reflect.Value {
// 处理零值或不可设置的情况
if !v.IsValid() {
return reflect.Zero(v.Type())
}
// 处理指针：解引用后拷贝，再取地址
if v.Kind() == reflect.Ptr {
if v.IsNil() {
return reflect.Zero(v.Type())
}
elem := deepCopyValue(v.Elem())
ptr := reflect.New(elem.Type())
ptr.Elem().Set(elem)
return ptr
}
// 处理 slice：新建 slice，逐项拷贝
if v.Kind() == reflect.Slice {
if v.IsNil() {
return reflect.Zero(v.Type())
}
newSlice := reflect.MakeSlice(v.Type(), v.Len(), v.Cap())
for i := 0; i < v.Len(); i++ {
newSlice.Index(i).Set(deepCopyValue(v.Index(i)))
}
return newSlice
}
// 处理 map：新建 map，递归拷贝键值对
if v.Kind() == reflect.Map {
if v.IsNil() {
return reflect.Zero(v.Type())
}
newMap := reflect.MakeMap(v.Type())
for _, key := range v.MapKeys() {
newKey := deepCopyValue(key)
newVal := deepCopyValue(v.MapIndex(key))
newMap.SetMapIndex(newKey, newVal)
}
return newMap
}
// 处理 struct：逐字段拷贝（仅导出字段）
if v.Kind() == reflect.Struct {
newStruct := reflect.New(v.Type()).Elem()
for i := 0; i < v.NumField(); i++ {
field := v.Field(i)
if !field.CanInterface() { // 跳过不可导出字段
continue
}
newStruct.Field(i).Set(deepCopyValue(field))
}
return newStruct
}
// 处理 interface{}：递归处理其底层值
if v.Kind() == reflect.Interface {
if v.IsNil() {
return reflect.Zero(v.Type())
}
return deepCopyValue(v.Elem())
}
// 基本类型、chan、func、unsafe.Pointer 等：直接返回（func/chan 不可拷贝，此处返回零值）
if v.CanInterface() {
return reflect.ValueOf(v.Interface())
}
return reflect.Zero(v.Type())
}
使用示例与注意事项
你可以这样使用它：
立即学习“go语言免费学习笔记（深入）”；
type Address struct {
City string
Code int
}
type Person struct {
Name string
Age int
Address *Address
Tags []string
Meta map[string]interface{}
}
p1 := &Person{
Name: "Alice",
Age: 30,
Address: &Address{City: "Beijing", Code: 100000},
Tags: []string{"dev", "golang"},
Meta: map[string]interface{}{"active": true, "score": 95.5},
}
p2 := DeepCopy(p1).(*Person) // 类型断言还原为 *Person
p2.Name = "Bob"
p2.Address.City = "Shanghai"
fmt.Println(p1.Name, p1.Address.City) // Alice Beijing（未被修改）
fmt.Println(p2.Name, p2.Address.City) // Bob Shanghai（独立副本）
注意：
- 该函数只拷贝可导出（首字母大写）字段，私有字段会被忽略
- 不支持函数类型、channel、unsafe.Pointer 的拷贝（这些类型本身无意义深拷贝）
- 不检测或处理循环引用，若结构体存在自引用（如树节点含 parent 指针），会无限递归 panic —— 如需支持，需额外维护已访问对象的地址缓存
- 性能不如手动克隆，高频场景建议结合代码生成（如
go:generate+deepcopy-gen）或序列化反序列化（如json.Marshal/Unmarshal，但会丢失非 JSON 友好类型）
更健壮的选择：使用成熟库
若项目允许引入依赖，推荐使用经过充分测试的开源方案：
-
jinzhu/copier：轻量、易用，支持标签控制（如jinzhu/copier） -
mohae/deepcopy：专注深拷贝，支持循环引用检测 -
ulule/deepcopier：链式调用、字段映射灵活
自己实现有助于理解原理，但工程中优先选用稳定库，减少边界 case 风险。
