17370845950

深拷贝结构体需用 reflect 手动遍历字段，确保目标可寻址、跳过不可导出字段、递归处理引用类型、校验类型兼容性，并避免误用 reflect.Copy。

用 reflect 深拷贝结构体字段时，零值和 nil 指针最易出错

Go 语言没有内置深拷贝函数，reflect 是最常用手段，但直接调用 reflect.Copy 或遍历赋值容易忽略字段可寻址性、类型兼容性和零值覆盖问题。比如把一个 *string 字段从源拷贝到目标，若目标字段是 nil，直接 Set() 会 panic；若源字段是零值（如空字符串、0），盲目覆盖可能破坏业务默认逻辑。

• 必须确保目标字段可寻址：用 reflect.ValueOf(&dst).Elem() 而非 reflect.ValueOf(dst)
• 跳过不可导出字段（首字母小写）：field.CanInterface() 不够，要检查 field.CanSet()
• 对指针、切片、map 等引用类型，需递归处理或显式分配新底层数组/哈希表，否则只是浅拷贝
• 注意结构体标签（如 json:"-" 或 copier:"skip"），需手动解析并跳过

reflect.Copy 只适用于切片，别误用于结构体字段赋值

reflect.Copy 的作用对象是 reflect.Value 类型的切片（Kind() == reflect.Slice），它不会遍历结构体字段，也不能处理嵌套结构。试图对两个结构体变量调用它会直接 panic：reflect.Copy: invalid argument types。结构体字段复制必须手动遍历 reflect.Type.Field 和 reflect.Value.Field。

• 正确做法：用 reflect.TypeOf(x).NumField() 获取字段数，循环中用 srcValue.Field(i) 和 dstValue.Field(i)
• 字段名匹配不是必须的：你可以按顺序拷贝，也可用 reflect.TypeOf(x).FieldByName("Name") 精确查找
• 类型不一致时，dstField.Set(srcField) 会 panic，需提前用 srcField.Type().AssignableTo(dstField.Type()) 校验

安全深拷贝结构体的最小可行实现（支持指针、slice、map、嵌套结构）

以下函数能处理常见复合类型，避免 panic，且不对不可导出字段或类型不匹配字段做任何操作：

func DeepCopy(dst, src interface{}) error {
	dstVal := reflect.ValueOf(dst)
	if dstVal.Kind() != reflect.Ptr || dstVal.IsNil() {
		return fmt.Errorf("dst must be a non-nil pointer")
	}
	dstVal = dstVal.Elem()
	srcVal := reflect.ValueOf(src)
	if !srcVal.IsValid() {
		return fmt.Errorf("src is invalid")
	}

	return deepCopyValue(dstVal, srcVal)
}

func deepCopyValue(dst, src reflect.Value) error {
	if !dst.CanSet() {
		return nil // 忽略不可设置字段
	}
	if src.Kind() == reflect.Ptr {
		if src.IsNil() {
			dst.Set(reflect.Zero(dst.Type()))
			return nil
		}
		if dst.Kind() != reflect.Ptr {
			return fmt.Errorf("type mismatch: expected %v, got ptr", dst.Type())
		}
		if dst.IsNil() || dst.IsNil() == src.IsNil() {
			dst.Set(reflect.New(dst.Type().Elem()))
		}
		return deepCopyValue(dst.Elem(), src.Elem())
	}

	if src.Kind() == reflect.Struct {
		for i := 0; i < src.NumField(); i++ {
			if !src.Field(i).CanInterface() {
				continue
			}
			if !dst.Field(i).CanSet() {
				continue
			}
			if err := deepCopyValue(dst.Field(i), src.Field(i)); err != nil {
				return err
			}
		}
		return nil
	}

	if src.Kind() == reflect.Slice || src.Kind() == reflect.Map || src.Kind() == reflect.Chan {
		dst.Set(src) // reflect 会自动 deep copy slice/map/chan 的 header，但底层数组/哈希表仍共享 —— 实际上这是 shallow，需按需重写
		return nil
	}

	dst.Set(src)
	return nil
}

注意：该实现对 slice 和 map 仍是浅拷贝（Go 官方 reflect 不提供原生深拷贝语义）。如需真正深拷贝，得在 reflect.Slice 分支里手动 Make 新切片并逐元素递归拷贝。

更稳妥的选择：用第三方库或生成代码，而非手写 reflect 拷贝逻辑

手写 reflect 拷贝极易遗漏 corner case：比如 unsafe.Pointer、func 类型、带 interface{} 字段的结构体、循环引用等。生产环境建议用成熟方案：

• github.com/mohae/deepcopy：轻量，专注深拷贝，处理大部分类型
• golang.org/x/exp/maps.Clone（Go 1.21+）：仅限 map，但标准库保障
• github.com/jinzhu/copier：支持 tag 控制（copier:"skip,from:xxx"）、类型转换、自定义函数
• 代码生成：用 go:generate + golang.org/x/tools/go/packages 分析结构体，生成无反射的字段赋值函数，性能高且 IDE 友好

真正难的不是“怎么拷”，而是“哪些字段不该拷”——比如数据库 ID、创建时间、上下文句柄。这些必须靠业务语义判断，reflect 本身无法替代设计决策。