「Go工具箱」推荐一个非常简单的深拷贝工具：deepcopy

package deepcopy
import (    "reflect"    "time")
// Interface for delegating copy process to typetype Interface interface {    DeepCopy() interface{}}
// Iface is an alias to Copy; this exists for backwards compatibility reasons.func Iface(iface interface{}) interface{} {    return Copy(iface)}
// Copy creates a deep copy of whatever is passed to it and returns the copy// in an interface{}.  The returned value will need to be asserted to the// correct type.func Copy(src interface{}) interface{} {    if src == nil {        return nil     }
    // Make the interface a reflect.Value    original := reflect.ValueOf(src)
    // Make a copy of the same type as the original.    cpy := reflect.New(original.Type()).Elem()
    // Recursively copy the original.    copyRecursive(original, cpy)
    // Return the copy as an interface.    return cpy.Interface()}
// copyRecursive does the actual copying of the interface. It currently has// limited support for what it can handle. Add as needed.func copyRecursive(original, cpy reflect.Value) {    // check for implement deepcopy.Interface    if original.CanInterface() {      if copier, ok := original.Interface().(Interface); ok {        cpy.Set(reflect.ValueOf(copier.DeepCopy()))        return      }    }
    // handle according to original's Kind    switch original.Kind() {      case reflect.Ptr:        // Get the actual value being pointed to.        originalValue := original.Elem()
        // if  it isn't valid, return.        if !originalValue.IsValid() {          return        }        cpy.Set(reflect.New(originalValue.Type()))        copyRecursive(originalValue, cpy.Elem())
      case reflect.Interface:        // If this is a nil, don't do anything        if original.IsNil() {          return        }        // Get the value for the interface, not the pointer.        originalValue := original.Elem()
        // Get the value by calling Elem().        copyValue := reflect.New(originalValue.Type()).Elem()        copyRecursive(originalValue, copyValue)        cpy.Set(copyValue)
      case reflect.Struct:        t, ok := original.Interface().(time.Time)        if ok {          cpy.Set(reflect.ValueOf(t))          return        }        // Go through each field of the struct and copy it.        for i := 0; i < original.NumField(); i++ {            // The Type's StructField for a given field is checked to see if StructField.PkgPath            // is set to determine if the field is exported or not because CanSet() returns false            // for settable fields.  I'm not sure why.  -mohae            if original.Type().Field(i).PkgPath != "" {              continue            }            copyRecursive(original.Field(i), cpy.Field(i))         }
      case reflect.Slice:        if original.IsNil() {          return        }        // Make a new slice and copy each element.        cpy.Set(reflect.MakeSlice(original.Type(), original.Len(), original.Cap()))        for i := 0; i < original.Len(); i++ {          copyRecursive(original.Index(i), cpy.Index(i))        }
      case reflect.Map:        if original.IsNil() {          return        }        cpy.Set(reflect.MakeMap(original.Type()))        for _, key := range original.MapKeys() {          originalValue := original.MapIndex(key)          copyValue := reflect.New(originalValue.Type()).Elem()          copyRecursive(originalValue, copyValue)          copyKey := Copy(key.Interface())          cpy.SetMapIndex(reflect.ValueOf(copyKey), copyValue)        }
      default:        cpy.Set(original)      }}

  a := []int{1,2,3}  dst := deepcopy.Copy(a)  a1 := dst.([]int)  a1[0] = 2  fmt.Println(a, a1) //a:[1 2 3] a1:[2 2 3]

  a := make(map[string]int)  a["k1"] = 1  a["k2"] = 2  a["k3"] = 3  dst := deepcopy.Copy(a)  a1 := dst.(map[string]int)  a1["k1"] = 10  fmt.Println(a, a1) //a:map[k1:1 k2:2 k3:3] a1:map[k1:10 k2:2 k3:3]