两个结构体变量中包含的类型相同

   func DeepFields(ifaceType reflect.Type) []reflect.StructField {
    	var fields []reflect.StructField
    
    	for i := 0; i < ifaceType.NumField(); i++ {
    		v := ifaceType.Field(i)
    		if v.Anonymous && v.Type.Kind() == reflect.Struct {
    			fields = append(fields, DeepFields(v.Type)...)
    		} else {
    			fields = append(fields, v)
    		}
    	}
    
    	return fields
    }
    
    func StructCopy(DstStructPtr interface{}, SrcStructPtr interface{}) {
    	srcv := reflect.ValueOf(SrcStructPtr)
    	dstv := reflect.ValueOf(DstStructPtr)
    	srct := reflect.TypeOf(SrcStructPtr)
    	dstt := reflect.TypeOf(DstStructPtr)
    	if srct.Kind() != reflect.Ptr || dstt.Kind() != reflect.Ptr ||
    		srct.Elem().Kind() == reflect.Ptr || dstt.Elem().Kind() == reflect.Ptr {
    		panic("Fatal error:type of parameters must be Ptr of value")
    	}
    	if srcv.IsNil() || dstv.IsNil() {
    		panic("Fatal error:value of parameters should not be nil")
    	}
    	srcV := srcv.Elem()
    	dstV := dstv.Elem()
    	srcfields := DeepFields(reflect.ValueOf(SrcStructPtr).Elem().Type())
    	for _, v := range srcfields {
    		if v.Anonymous {
    			continue
    		}
    		dst := dstV.FieldByName(v.Name)
    		src := srcV.FieldByName(v.Name)
    		if !dst.IsValid() {
    			continue
    		}
    		if src.Type() == dst.Type() && dst.CanSet() {
    			dst.Set(src)
    			continue
    		}
    		if src.Kind() == reflect.Ptr && !src.IsNil() && src.Type().Elem() == dst.Type() {
    			dst.Set(src.Elem())
    			continue
    		}
    		if dst.Kind() == reflect.Ptr && dst.Type().Elem() == src.Type() {
    			dst.Set(reflect.New(src.Type()))
    			dst.Elem().Set(src)
    			continue
    		}
    	}
    	return
    }
    type Src struct {
    	Name string
    	ID  string
    }
    
    type Dst struct {
    	Name string
    	ID  string
    }
    //测试如下：
    src := &Src{"wilson", "007"}
	var dst Dst
	StructCopy(&dst, src)
	fmt.Println(dst)

下面开始讨论两个结构体变量的类型相同，即同一种类型的结构体赋值

package main

import (
	"fmt"
	"encoding/json"
)

type Foo1 struct {
	id int
	m  map[int]string
}



func main() {



	//funcName()
	//var f1 Foo1
	f1 := &Foo1{id: 3, m: map[int]string{1: "hello", 2: "hello1"}}
	var f2 Foo1
	f2.m = make(map[int]string)
	for key, value := range f1.m {
		//f2.m[key]=value
		f2.m[key] = value
	}
	f2.m[1]="world"


	fmt.Println(&f2)
	fmt.Println(f1)
}