当前位置：首页 > 文章列表 > Golang > Go教程 > Golangreflect实现对象复制方法解析

Golangreflect实现对象复制方法解析

2026-02-11 22:19:35 0浏览收藏

从现在开始，努力学习吧！本文《Golang reflect实现对象拷贝方法》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

使用 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 或结构体字段时只会复制引用，修改副本会影响原数据。要实现深拷贝，需递归复制这些字段。

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

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 类型，确保每一层都是独立的新对象。注意：此版本未处理指针字段指向结构体的情况，可根据需要扩展。