一文带你搞懂Go语言中深拷贝与浅拷贝

在Go语言中，深拷贝和浅拷贝是两种常见的对象复制方式，它们在处理复杂数据结构时具有不同的特点和用途。本文旨在帮助你深入了解这两种拷贝方式的原理和应用，以便在实际开发中正确选择和使用。

浅拷贝

浅拷贝是指只复制对象的顶层结构，对于对象内部的引用类型字段，只复制其引用地址，而不复制实际的数据。换句话说，浅拷贝后的对象与原始对象共享内部引用类型字段的数据。

在Go语言中，当我们使用赋值操作（=）将一个对象赋值给另一个对象时，实际上执行的就是浅拷贝。例如：

type Person struct {
    Name string
    Age  int
    Addr *Address
}

type Address struct {
    City   string
    Street string
}

func main() {
    addr := &Address{City: "Beijing", Street: "Chaoyang"}
    p1 := Person{Name: "Alice", Age: 30, Addr: addr}
    p2 := p1 // 浅拷贝

    p2.Addr.City = "Shanghai"
    fmt.Println(p1.Addr.City) // 输出: Shanghai
}

在上面的例子中，我们创建了一个Person结构体，其中包含一个指向Address结构体的指针字段Addr。当我们将p1赋值给p2时，执行的是浅拷贝。因此，p1和p2中的Addr字段都指向同一个Address对象。当我们修改p2.Addr.City时，p1.Addr.City也会相应地改变，因为它们共享同一个Address对象。

深拷贝

深拷贝是指不仅复制对象的顶层结构，还递归地复制对象内部的所有引用类型字段的数据。这样，深拷贝后的对象与原始对象完全独立，修改其中一个对象不会影响另一个对象。

在Go语言中，实现深拷贝通常需要使用反射（reflection）或序列化/反序列化等方法。下面是一个使用反射实现深拷贝的示例：

import (
    "fmt"
    "reflect"
)

func deepCopy(src interface{}) interface{} {
    val := reflect.ValueOf(src)
    if val.Kind() != reflect.Ptr {
        return val.Interface()
    }

    // 创建新的指针类型实例
    newVal := reflect.New(val.Type().Elem()).Elem()

    // 递归复制字段值
    deepCopyValue(newVal, val.Elem())

    return newVal.Interface()
}

func deepCopyValue(dst, src reflect.Value) {
    switch src.Kind() {
    case reflect.Ptr:
        if src.IsNil() {
            return
         }
        // 创建新的指针类型实例
        newVal := reflect.New(src.Type().Elem())
        dst.Set(newVal)
        // 递归复制指针指向的值
        deepCopyValue(newVal.Elem(), src.Elem())
    case reflect.Slice:
        // 创建新的切片实例
        slice := reflect.MakeSlice(src.Type(), src.Len(), src.Cap())
        dst.Set(slice)
        // 递归复制切片中的每个元素
        for i := 0; i < src.Len(); i++ {
            deepCopyValue(slice.Index(i), src.Index(i))
        }
    case reflect.Struct:
        // 复制结构体的每个字段
        for i := 0; i < src.NumField(); i++ {
            deepCopyValue(dst.Field(i), src.Field(i))
        }
    // 其他类型直接复制值即可
    default:
        dst.Set(src)
    }
}

func main() {
    addr := &Address{City: "Beijing", Street: "Chaoyang"}
    p1 := Person{Name: "Alice", Age: 30, Addr: addr}
    p2 := deepCopy(p1).(Person) // 深拷贝

    p2.Addr.City = "Shanghai"
    fmt.Println(p1.Addr.City) // 输出: Beijing
}

在上面的例子中，我们定义了一个deepCopy函数，它使用反射递归地复制对象的所有字段。这样，当我们调用deepCopy(p1).(Person)时，会得到一个与p1完全独立的Person对象。修改p2.Addr.City不会影响p1.Addr.City的值。

总结

浅拷贝和深拷贝是Go语言中处理对象复制时的两种重要方式。它们的主要区别在于处理引用类型字段时的行为不同。

• 理解数据结构的复制方式：在对数据进行拷贝操作时，要明确是进行浅拷贝还是深拷贝，以避免意外的数据共享或修改。

• 避免数据共享带来的问题：当多个变量共享同一份数据时，一个变量的修改可能会影响其他变量。在需要独立操作数据时，应该使用深拷贝来复制数据。

• 性能考虑：深拷贝通常比浅拷贝更耗时，因为需要复制整个数据结构。在处理大型数据集时，需要权衡性能和数据独立性。

• 使用copy()函数进行切片拷贝：对于切片类型的数据，可以使用copy()函数进行浅拷贝，或者手动遍历并复制每个元素来实现深拷贝。

浅拷贝只复制对象的顶层结构，对于引用类型字段，只复制其引用地址。这意味着浅拷贝后的对象与原始对象共享内部引用类型字段的数据。修改其中一个对象中的引用类型字段会影响另一个对象，因为它们指向的是同一块内存地址。

深拷贝则不仅复制对象的顶层结构，还递归地复制对象内部的所有引用类型字段的数据。深拷贝后的对象与原始对象完全独立，修改其中一个对象不会影响另一个对象。实现深拷贝通常需要使用反射或序列化/反序列化等方法，这可能会比浅拷贝更加复杂和耗时。

在实际开发中，选择使用浅拷贝还是深拷贝取决于具体的需求和场景。如果对象内部只包含值类型字段，或者引用类型字段不需要独立修改，那么浅拷贝是一个简单而高效的选择。然而，如果对象内部包含需要独立修改的引用类型字段，或者需要确保对象之间的完全独立性，那么应该使用深拷贝。