Golang深拷贝浅拷贝

在了解原型设计模式之前我们需要新知道Golang的深拷贝与浅拷贝之间的区别。

推荐大家新看看Slice 和 Map那么常见的坑：https://blog.csdn.net/weixin_40165163/article/details/90707593

github:https://github.com/zhumengyifang/GolangDesignPatterns

数据结构：

//速度速值
type Speed int//风扇转速
type FanSpeed struct {Speed Speed
}//售价
type Money struct {Length float64
}//内存数量以及大小
type Memory struct {Count      intMemorySize []int
}//电脑信息
type Computer struct {SystemName string              //系统名字UseNumber  int                 //使用次数Memory     Memory              //存储Fan        map[string]FanSpeed //风扇Money      Money               //售价
}

浅拷贝：

接触过 Java或者C#的同学应该知道浅拷贝对于值类型的话是完全拷贝一份，而对于引用类型是拷贝其地址。也就是拷贝的对象修改引用类型的变量同样会影响到源对象。

这里Golang同理，在上述测试类型中涉及到 Slice 和 Map的修改则会互相影响。

测试1：

func ComputerStart1() {Pc1 := Computer{SystemName: "Windows",UseNumber:  1000,Memory:     Memory{Count: 4, MemorySize: []int{32, 32, 32, 32}},Fan:        map[string]FanSpeed{"left": {2500}, "right": {2000}},Money:      Money{123.45},}//浅拷贝Pc2:=Pc1fmt.Printf("PcInfo Pc1:%v, Pc2:%v\n", Pc1, Pc2)//修改切片内容以及map信息影响Pc1Pc2.SystemName ="MacOs"Pc2.UseNumber =100Pc2.Memory.Count =2Pc2.Memory.MemorySize[0]=8Pc2.Memory.MemorySize[1]=8Pc2.Memory.MemorySize[2]=0Pc2.Memory.MemorySize[3]=0Pc2.Fan["left"]=FanSpeed{2000}Pc2.Fan["right"]=FanSpeed{1500}fmt.Printf("PcInfo Pc1:%v, Pc2:%v\n", Pc1, Pc2)
}

输入信息：

PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}, Pc2:{MacOs 100 {2 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}

对于PC2的修改影响到了PC1的Slice 和 Map

测试2：

func ComputerStart2() {Pc1 := Computer{SystemName: "Windows",UseNumber:  1000,Memory:     Memory{Count: 4, MemorySize: []int{32, 32, 32, 32}},Fan:        map[string]FanSpeed{"left": {2500}, "right": {2000}},Money:      Money{123.45},}//浅拷贝Pc2:=Pc1fmt.Printf("PcInfo Pc1:%v, Pc2:%v\n", Pc1, Pc2)ModifyCat(Pc2)fmt.Printf("PcInfo Pc1:%v, Pc2:%v\n", Pc1, Pc2)
}func ModifyCat(pc Computer) {fmt.Printf("PcInfo Pc1:%v\n", pc)pc.SystemName ="MacOs"pc.UseNumber =100pc.Memory.Count =2pc.Memory.MemorySize[0]=8pc.Memory.MemorySize[1]=8pc.Memory.MemorySize[2]=0pc.Memory.MemorySize[3]=0pc.Fan["left"]=FanSpeed{2000}pc.Fan["right"]=FanSpeed{1500}fmt.Printf("PcInfo Pc1:%v\n", pc)
}

输入：

PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{MacOs 100 {2 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}, Pc2:{Windows 1000 {4 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}

这里在方法中修改PC2同样影响到了 PC1以及PC2，是因为在Golang中方法中传递的参数同样被拷贝了一份，他们修改的Slice 和 Map都是同一份地址。

那么对于浅拷贝来说如何避免这种情况的发生呢？

测试3：

func ComputerStart2() {Pc1 := Computer{SystemName: "Windows",UseNumber:  1000,Memory:     Memory{Count: 4, MemorySize: []int{32, 32, 32, 32}},Fan:        map[string]FanSpeed{"left": {2500}, "right": {2000}},Money:      Money{123.45},}//浅拷贝Pc2:=Pc1fmt.Printf("PcInfo Pc1:%v, Pc2:%v\n", Pc1, Pc2)//切片以及map新空间互不影响Pc2.SystemName ="MacOs"Pc2.UseNumber =100Pc2.Memory =Memory{Count: 2, MemorySize: []int{8, 8}}Pc2.Fan =map[string]FanSpeed{"left": {2000}, "right": {1500}}Pc2.Money =Money{1000.45}fmt.Printf("PcInfo Pc1:%v, Pc2:%v\n", Pc1, Pc2)
}

输出：

PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:{MacOs 100 {2 [8 8]} map[left:{2000} right:{1500}] {1000.45}}

既然只有Slice 和 Map会受到影响我们这里重新给定地址重新生成一个Slice和Map就可以不受影响。

深拷贝

对于深拷贝就比较好了解了，任何对象都会被完完整整的拷贝一份，拷贝对象与被拷贝对象不存在如何联系，也就不会互相影响。如果你需要拷贝的对象中没有引用类型，那么对于Golang而言使用浅拷贝就可以了。

基于序列化和反序列化来实现对象的深度拷贝:

func deepCopy(dst, src interface{}) error {var buf bytes.Bufferif err := gob.NewEncoder(&buf).Encode(src); err != nil {return err}return gob.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dst)
}

需要深拷贝的变量必须首字母大写才可以被拷贝

测试1：

func ComputerStart4() {Pc1 := &Computer{SystemName: "Windows",UseNumber:  1000,Memory:     Memory{Count: 4, MemorySize: []int{32, 32, 32, 32}},Fan:        map[string]FanSpeed{"left": {2500}, "right": {2000}},Money:      Money{123.45},}//深拷贝Pc2:= new(Computer)if err:= deepCopy(Pc2,Pc1);err!=nil{panic(err.Error())}fmt.Printf("PcInfo Pc1:%v, Pc2:%v\n", Pc1, Pc2)ModifyCat1(*Pc2)fmt.Printf("PcInfo Pc1:%v, Pc2:%v\n", Pc1, Pc2)
}

输出：

PcInfo Pc1:&{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:&{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{MacOs 100 {2 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}
PcInfo Pc1:&{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:&{Windows 1000 {4 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}

可以看到PC2经过浅拷贝（参数传递）在修改Slice和Map受到影响的也只有PC2和PC2的浅拷贝对象。对于PC1没有任何影响。

下一章原型设计模式：https://blog.csdn.net/weixin_40165163/article/details/90671135