Golang如何使用reflect实现对象拷贝_Golang reflect对象复制与深拷贝实践-Golang-PHP中文网

Golang如何使用reflect实现对象拷贝_Golang reflect对象复制与深拷贝实践

P粉602998670

发布： 2025-12-02 20:19:03

原创

255人浏览过

使用 reflect 包可实现 Go 中的深拷贝，通过递归处理 struct、slice 和 map 类型，确保各层独立；适用于配置复制等低频场景，但性能较低且不支持私有字段与循环引用。

golang如何使用reflect实现对象拷贝_golang reflect对象复制与深拷贝实践

在 Go 语言中，没有内置的深拷贝机制，当需要复制结构体尤其是嵌套结构时，reflect 包成为实现通用对象拷贝的有效手段。通过反射，可以动态读取和设置字段值，从而实现浅拷贝或深拷贝逻辑。

使用 reflect 实现基础对象拷贝

利用 reflect.Value 和 reflect.Type 可以遍历结构体字段并逐个赋值。以下是一个简单的浅拷贝实现：

func Copy(dst, src interface{}) error {
    dstVal := reflect.ValueOf(dst)
    srcVal := reflect.ValueOf(src)

    if dstVal.Kind() != reflect.Ptr || !dstVal.Elem().CanSet() {
        return fmt.Errorf("dst must be a settable pointer")
    }

    srcVal = srcVal.Elem()
    dstVal = dstVal.Elem()

    for i := 0; i < srcVal.NumField(); i++ {
        field := srcVal.Field(i)
        if dstVal.Field(i).CanSet() {
            dstVal.Field(i).Set(field)
        }
    }
    return nil
}

登录后复制

这个函数要求传入目标和源对象的指针，并将源结构体的每个字段复制到目标中。适用于字段类型相同且不包含引用类型（如 slice、map、指针）的场景。

处理嵌套结构与引用类型的深拷贝

浅拷贝在遇到 slice、map 或结构体字段时只会复制引用，修改副本会影响原数据。要实现深拷贝，需递归复制这些字段。

立即学习“go语言免费学习笔记（深入）”；

核心思路是判断字段是否为可迭代的引用类型，如果是，则创建新实例并递归填充：

无涯·问知

无涯·问知，是一款基于星环大模型底座，结合个人知识库、企业知识库、法律法规、财经等多种知识源的企业级垂直领域问答产品

153

查看详情

func DeepCopy(dst, src interface{}) error {
    dstVal := reflect.ValueOf(dst)
    srcVal := reflect.ValueOf(src)

    if dstVal.Kind() != reflect.Ptr || !dstVal.Elem().CanSet() {
        return fmt.Errorf("dst must be a settable pointer")
    }

    if srcVal.Kind() == reflect.Ptr {
        srcVal = srcVal.Elem()
    }

    dstVal = dstVal.Elem()
    walkValue(dstVal, srcVal)
    return nil
}

func walkValue(dst, src reflect.Value) {
    for i := 0; i < src.NumField(); i++ {
        srcField := src.Field(i)
        dstField := dst.Field(i)

        if !dstField.CanSet() {
            continue
        }

        switch srcField.Kind() {
        case reflect.Struct:
            walkValue(dstField, srcField)
        case reflect.Slice:
            if srcField.IsNil() {
                continue
            }
            newSlice := reflect.MakeSlice(srcField.Type(), srcField.Len(), srcField.Cap())
            for j := 0; j < srcField.Len(); j++ {
                elem := srcField.Index(j)
                newElem := reflect.New(elem.Type()).Elem()
                walkValue(newElem, elem)
            }
            dstField.Set(newSlice)
        case reflect.Map:
            if srcField.IsNil() {
                continue
            }
            newMap := reflect.MakeMap(srcField.Type())
            for _, key := range srcField.MapKeys() {
                val := srcField.MapIndex(key)
                newVal := reflect.New(val.Type()).Elem()
                walkValue(newVal, val)
                newMap.SetMapIndex(key, newVal)
            }
            dstField.Set(newMap)
        default:
            dstField.Set(srcField)
        }
    }
}

登录后复制

上述代码递归处理 struct、slice 和 map 类型，确保每一层都是独立的新对象。注意：此版本未处理指针字段指向结构体的情况，可根据需要扩展。