How to implement deep copy in golang

In Go language (golang), we often need to copy structures or objects. Direct assignment or shallow copying may cause errors that are difficult to debug. Therefore, deep copy is very necessary. This article will introduce how golang implements deep copy.

The concept of deep copy

Deep copy is to create a new copy of all the internal attributes of an object. In this way, even if a certain attribute is modified in the original object and the copy, it will not affect each other. Shallow copy only copies pointers, and multiple objects point to the same address. Modifying the properties of one object will affect other objects.

Deep copy method in golang

Method 1: Use json.Marshal() and json.Unmarshal()

This method is relatively simple and can be used in the standard library The json.Marshal() and json.Unmarshal() functions.

For example:

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实例

However, this method has some disadvantages. First of all, you need to ensure that the converted json format does not have the same json as the field, otherwise the json cannot be converted back to the structure. Secondly, both json.Marshal() and json.Unmarshal() need to traverse the entire object, resulting in slower speed. Therefore, it cannot be used for complex data structures and applications requiring efficient performance.

Method 2: Use the recursive method

Recursive deep copy is the most commonly used method. Traverse each element in the object or array, copy it directly if it is a basic type, or call the deep copy function recursively if it is a complex type. The code is as follows:

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)))
    }
}

In this code, we first use reflect.TypeOf() to get the object type, and then call different deep copy functions based on the type definition.

We can test common types:

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)
}

The output results are as follows:

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

It can be seen that the values ​​​​of obj1 and obj2 are different, and modifying the value of obj1 will not affect obj2 .

Summary

This article introduces two methods of deep copying in golang. For simple structures, you can use json.Marshal() and json.Unmarshal(). For complex data structures, recursive methods can be used for deep copying. When performing deep copy, you need to pay attention to the judgment of data type to avoid unnecessary errors.

The above is the detailed content of How to implement deep copy in golang. For more information, please follow other related articles on the PHP Chinese website!