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

package deepcopy

import (
    "reflect"
    "time"
)

// Interface for delegating copy process to type
type 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]