golang怎么实现深拷贝

在Go语言（golang）中，我们经常需要对结构体或者对象进行拷贝。如果直接赋值或者浅拷贝，可能会带来难以调试的错误。因此，深拷贝是非常必要的。本文将介绍golang如何实现深拷贝。

深拷贝的概念

深拷贝是对一个对象的所有内部属性都新建一个副本。这样即使在原对象和副本中修改了某个属性，也不会互相影响。而浅拷贝则是只复制指针，多个对象指向同一个地址。修改其中一个对象的属性，会影响其他对象。

golang中的深拷贝方法

方法一：采用json.Marshal()和json.Unmarshal()

这种方法比较简单，可以使用标准库中的json.Marshal()和json.Unmarshal()函数。

举个例子：

type Person struct {
    Name string
    Age int
}

person1 := &Person{"Lucas", 18}
var person2 Person

temp, _ := json.Marshal(person1) //使用json.Marshal()将person1转换成json格式
json.Unmarshal(temp, &person2) //使用json.Unmarshal()将json格式转换成person2实例

不过，这种方法有一些缺点。首先，需要确保转换成的json格式不会出现与字段相同的json，否则就无法将json转换回结构体。其次，json.Marshal()和json.Unmarshal()都需要遍历整个对象，导致速度比较慢。因此，不能用于复杂的数据结构和需要高效性能的应用程序。

方法二：使用递归方法

递归深拷贝是最常用的方法。遍历对象或数组中的每个元素，如果是基本类型则直接复制，如果是复杂类型则递归调用深拷贝函数。代码如下：

func DeepCopy(input interface{}) interface{} {
    if input == nil {
        return nil
    }

    switch reflect.TypeOf(input).Kind() {

    case reflect.Bool, reflect.String, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Float32, reflect.Float64:
        return input

    case reflect.Struct:
        in := reflect.ValueOf(input)
        out := reflect.New(in.Type()).Elem()

        for i := 0; i < in.NumField(); i++ {
            out.Field(i).Set(DeepCopy(in.Field(i).Interface()))
        }
        return out.Interface()

    case reflect.Array, reflect.Slice:
        in := reflect.ValueOf(input)
        out := reflect.MakeSlice(in.Type(), in.Len(), in.Cap())

        for i := 0; i < in.Len(); i++ {
            out.Index(i).Set(DeepCopy(in.Index(i).Interface()))
        }
        return out.Interface()

    case reflect.Map:
        in := reflect.ValueOf(input)
        out := reflect.MakeMapWithSize(in.Type(), in.Len())

        for _, key := range in.MapKeys() {
            out.SetMapIndex(DeepCopy(key.Interface()).(reflect.Value), DeepCopy(in.MapIndex(key).Interface()).(reflect.Value))
        }
        return out.Interface()

    default:
        panic(fmt.Sprintf("Unable to deepcopy object of type %v", reflect.TypeOf(input)))
    }
}

在这段代码中，我们首先使用reflect.TypeOf()获取对象类型，然后根据类型定义调用不同的深拷贝函数。

我们可以对常用类型进行测试：

type Person struct {
    Name string
    Age int
}

type Object struct {
    Num int
    Str string
    Slice []int
    Map map[string]int
    Person Person
}

func main() {

    obj1 := &Object{1, "hello", []int{2, 3}, map[string]int{"age": 18}, Person{"Lucas", 20}}

    //深拷贝
    obj2 := DeepCopy(obj1)

    //修改obj1的Name字段
    obj1.Person.Name = "Nina"

    fmt.Println("obj1:", obj1)
    fmt.Println("obj2:", obj2)
}

输出结果如下：

obj1: &{1 hello [2 3] map[age:18] {Nina 20}}
obj2: &{1 hello [2 3] map[age:18] {Lucas 20}}

可见，obj1和obj2的值不同，修改obj1的值并不会影响obj2。

总结

本文介绍了golang中深拷贝的两种方法。对于简单的结构体，可以使用json.Marshal()和json.Unmarshal()。对于复杂的数据结构，可以使用递归方法进行深拷贝。在进行深拷贝时，需要注意数据类型的判断，避免出现不必要的错误。

以上就是golang怎么实现深拷贝的详细内容，更多请关注其它相关文章！