【golang】2、深拷贝-浅拷贝-方式与性能对比：Reflect、GobEncode、JsonMarshal

已于 2022-10-10 13:26:56 修改
阅读量1.3k 收藏 1
点赞数 3
分类专栏： # golang 文章标签： golang 数据结构
于 2022-08-29 22:02:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiaoyangwm/article/details/126592385
版权

文章目录


在这里插入图片描述

概念

各编程语言都有深浅拷贝的概念, 它们的核心是拷贝的是地址(浅拷贝)还是值(深拷贝), 今天我们就对其概念介绍, 并做性能对比和特性对比

浅拷贝

  • 拷贝的只是数据的地址. 新老对象共享内存
  • 当改新对象时, 老对象也会被改变. 当释放新对象时, 老对象也会被释放.
  • 浅拷贝的数据类型, 即引用类型数据: 有Slice(无论原生类型或结构体slice), Map

深拷贝

  • 深拷贝的是数据的内容, 会创建新对象, 新老对象不共享内存
  • 当改变新对象时, 和老对象没关系; 当释放新对象时, 和老对象也没关系; 总之就是新老对象没任何关系
  • 深拷贝的数据类型, 即值类型数据: 有Struct, Array, Int, String, Float, Bool

用途

当我们需要拷贝一个新对象时, 怎么选择呢? 显然

  • 当需要节省内存时, 可选浅拷贝, 因为只是复制了地址
  • 当为了操作简便时, 可选浅拷贝, 直接a := b即可
  • 而当需要开辟新内存, 分别处理新老对象, 使两者互不干扰时, 则需要深拷贝
    • 例如数据流业务的多条支流间, 若均存在改写对象的操作, 则需深拷贝, 防止A逻辑分支改了a对象, 而后续B逻辑分支意外的使用了被别人改过的对象

在这里插入图片描述

性能对比

有Reflect, GobEncode, JsonMarshal几种方式, 我们做一个Benchmark试验如下

  • 定义数据类型
type InnerStruct struct {
	Int    int
	String string
}
type CType struct {
	Int         int
	String      string
	Struct      InnerStruct
	IntSlice    []int
	StringSlice []string
	StructSlice []InnerStruct
	IntArray    [2]int
	StringArray [2]string
	StructArray [2]InnerStruct
	Map         map[string]string
}
  • 初始化数据
c := &CType{
	Int:         1,
	String:      "2",
	Struct:      InnerStruct{Int: 3, String: "4"},
	IntSlice:    []int{5, 6},
	StringSlice: []string{"7", "8"},
	StructSlice: []InnerStruct{{Int: 9, String: "10"}, {Int: 11, String: "12"}},
	IntArray:    [2]int{13, 14},
	StringArray: [2]string{"15", "16"},
	StructArray: [2]InnerStruct{{Int: 17, String: "18"}, {Int: 19, String: "20"}},
	Map:         map[string]string{"21": "22", "23": "24"},
}

测试电脑为cpu: Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz

浅拷贝

func BenchmarkShallowCopy(b *testing.B) {
	for n := 0; n < b.N; n++ {
		c.ShallowCopy()
	}
}

结果为BenchmarkShallowCopy 0.7702 ns/op

Reflect

func BenchmarkReflect(b *testing.B) {
	for n := 0; n < b.N; n++ {
		c.DeepCopyReflect()
	}
}

结果为BenchmarkReflect 4515 ns/op

JsonMarshal

func BenchmarkJsonMarshal(b *testing.B) {
	for n := 0; n < b.N; n++ {
		c.DeepCopyJsonMarshal()
	}
}

结果为BenchmarkJsonMarshal 11133 ns/op

GobEncode

func BenchmarkGobMarshal(b *testing.B) {
	for n := 0; n < b.N; n++ {
		c.DeepCopyGobMarshal()
	}
}

结果为BenchmarkGobMarshal 54298 ns/op
综上, 浅拷贝性能>Reflect性能>JsonMarshal性能>GobMarshal

在这里插入图片描述

特点对比

做完性能对别后, 我们还需对别深浅拷贝是否对新对象的写操作有影响

同样用上文性能对比的数据, 分别测试对拷贝后新对象的写操作, 是否影响老对象, 结果如下

浅拷贝

func TestShallowCopy(t *testing.T) {
	r := c.ShallowCopy()
	r.Int += 10000
	r.String += "changed"
	r.Struct.Int += 10000
	r.Struct.String += "changed"
	r.IntSlice[0] += 10000
	r.IntSlice[1] += 10000
	r.StringSlice[0] += "changed"
	r.StringSlice[1] += "changed"
	r.StructSlice[0].Int += 10000
	r.StructSlice[0].String += "changed"
	r.StructSlice[1].Int += 10000
	r.StructSlice[1].String += "changed"
	r.IntArray[0] += 10000
	r.IntArray[1] += 10000
	r.StringArray[0] += "changed"
	r.StringArray[1] += "changed"
	r.StructArray[0].Int += 10000
	r.StructArray[0].String += "changed"
	r.StructArray[1].Int += 10000
	r.StructArray[1].String += "changed"
	r.Map["21"] += "changed"
	r.Map["23"] += "changed"
	rByte, _ := json.MarshalIndent(r, "", "  ")
	t.Log(string(rByte))
}

结果如下可见, 确实只有Slice(无论原生类型或结构体slice), Map有影响, 其他类型均无影响

=== RUN   TestShallowCopy
    main_test.go:117: {
          "Int": 1,
          "String": "2",
          "Struct": {
            "Int": 3,
            "String": "4"
          },
          "IntSlice": [
            10005,
            10006
          ],
          "StringSlice": [
            "7changed",
            "8changed"
          ],
          "StructSlice": [
            {
              "Int": 10009,
              "String": "10changed"
            },
            {
              "Int": 10011,
              "String": "12changed"
            }
          ],
          "IntArray": [
            13,
            14
          ],
          "StringArray": [
            "15",
            "16"
          ],
          "StructArray": [
            {
              "Int": 17,
              "String": "18"
            },
            {
              "Int": 19,
              "String": "20"
            }
          ],
          "Map": {
            "21": "22changed",
            "23": "24changed"
          }
        }

Reflect

func TestDeepCopyReflect(t *testing.T) {
	r := c.DeepCopyReflect()
	r.Int += 10000
	r.String += "changed"
	r.Struct.Int += 10000
	r.Struct.String += "changed"
	r.IntSlice[0] += 10000
	r.IntSlice[1] += 10000
	r.StringSlice[0] += "changed"
	r.StringSlice[1] += "changed"
	r.StructSlice[0].Int += 10000
	r.StructSlice[0].String += "changed"
	r.StructSlice[1].Int += 10000
	r.StructSlice[1].String += "changed"
	r.IntArray[0] += 10000
	r.IntArray[1] += 10000
	r.StringArray[0] += "changed"
	r.StringArray[1] += "changed"
	r.StructArray[0].Int += 10000
	r.StructArray[0].String += "changed"
	r.StructArray[1].Int += 10000
	r.StructArray[1].String += "changed"
	r.Map["21"] += "changed"
	r.Map["23"] += "changed"
	rByte, _ := json.MarshalIndent(c, "", "  ")
	t.Log(string(rByte))
}

结果如下, 确实新对象的任何改动, 都没影响老对象

=== RUN   TestDeepCopyReflect
    main_test.go:117: {
          "Int": 1,
          "String": "2",
          "Struct": {
            "Int": 3,
            "String": "4"
          },
          "IntSlice": [
            5,
            6
          ],
          "StringSlice": [
            "7",
            "8"
          ],
          "StructSlice": [
            {
              "Int": 9,
              "String": "10"
            },
            {
              "Int": 11,
              "String": "12"
            }
          ],
          "IntArray": [
            13,
            14
          ],
          "StringArray": [
            "15",
            "16"
          ],
          "StructArray": [
            {
              "Int": 17,
              "String": "18"
            },
            {
              "Int": 19,
              "String": "20"
            }
          ],
          "Map": {
            "21": "22",
            "23": "24"
          }
        }

JsonMarshal

func TestDeepCopyJsonMarshal(t *testing.T) {
	r := c.DeepCopyJsonMarshal()
	r.Int += 10000
	r.String += "changed"
	r.Struct.Int += 10000
	r.Struct.String += "changed"
	r.IntSlice[0] += 10000
	r.IntSlice[1] += 10000
	r.StringSlice[0] += "changed"
	r.StringSlice[1] += "changed"
	r.StructSlice[0].Int += 10000
	r.StructSlice[0].String += "changed"
	r.StructSlice[1].Int += 10000
	r.StructSlice[1].String += "changed"
	r.IntArray[0] += 10000
	r.IntArray[1] += 10000
	r.StringArray[0] += "changed"
	r.StringArray[1] += "changed"
	r.StructArray[0].Int += 10000
	r.StructArray[0].String += "changed"
	r.StructArray[1].Int += 10000
	r.StructArray[1].String += "changed"
	r.Map["21"] += "changed"
	r.Map["23"] += "changed"
	rByte, _ := json.MarshalIndent(c, "", "  ")
	t.Log(string(rByte))
}

结果如下, 确实新对象的任何改动, 都没影响老对象

=== RUN   TestDeepCopyJsonMarshal
    main_test.go:117: {
          "Int": 1,
          "String": "2",
          "Struct": {
            "Int": 3,
            "String": "4"
          },
          "IntSlice": [
            5,
            6
          ],
          "StringSlice": [
            "7",
            "8"
          ],
          "StructSlice": [
            {
              "Int": 9,
              "String": "10"
            },
            {
              "Int": 11,
              "String": "12"
            }
          ],
          "IntArray": [
            13,
            14
          ],
          "StringArray": [
            "15",
            "16"
          ],
          "StructArray": [
            {
              "Int": 17,
              "String": "18"
            },
            {
              "Int": 19,
              "String": "20"
            }
          ],
          "Map": {
            "21": "22",
            "23": "24"
          }
        }

GobEncode

func TestDeepCopyGobMarshal(t *testing.T) {
	r := c.DeepCopyGobMarshal()
	r.Int += 10000
	r.String += "changed"
	r.Struct.Int += 10000
	r.Struct.String += "changed"
	r.IntSlice[0] += 10000
	r.IntSlice[1] += 10000
	r.StringSlice[0] += "changed"
	r.StringSlice[1] += "changed"
	r.StructSlice[0].Int += 10000
	r.StructSlice[0].String += "changed"
	r.StructSlice[1].Int += 10000
	r.StructSlice[1].String += "changed"
	r.IntArray[0] += 10000
	r.IntArray[1] += 10000
	r.StringArray[0] += "changed"
	r.StringArray[1] += "changed"
	r.StructArray[0].Int += 10000
	r.StructArray[0].String += "changed"
	r.StructArray[1].Int += 10000
	r.StructArray[1].String += "changed"
	r.Map["21"] += "changed"
	r.Map["23"] += "changed"
	rByte, _ := json.MarshalIndent(c, "", "  ")
	t.Log(string(rByte))
}

结果如下, 确实新对象的任何改动, 都没影响老对象

=== RUN   TestDeepCopyGobMarshal
    main_test.go:117: {
          "Int": 1,
          "String": "2",
          "Struct": {
            "Int": 3,
            "String": "4"
          },
          "IntSlice": [
            5,
            6
          ],
          "StringSlice": [
            "7",
            "8"
          ],
          "StructSlice": [
            {
              "Int": 9,
              "String": "10"
            },
            {
              "Int": 11,
              "String": "12"
            }
          ],
          "IntArray": [
            13,
            14
          ],
          "StringArray": [
            "15",
            "16"
          ],
          "StructArray": [
            {
              "Int": 17,
              "String": "18"
            },
            {
              "Int": 19,
              "String": "20"
            }
          ],
          "Map": {
            "21": "22",
            "23": "24"
          }
        }
呆呆的猫
关注
专栏目录
Go 语言对象深拷贝方式性能分析
01-08
深度拷贝可以通过序列化和反序列化来实现，也可以基于reflect包的反射机制完成。我对于这两种方式实现深拷贝做了性能基准测试。 下面是对比反射（github.com/mohae/deepcopy）与序列化（gob）所用的基准测试脚本 deepcopy_test.go package deepcopy import ( bytes encoding/gob testing github.com/mohae/deepcopy ) type Basics struct { String string Strings [
Golang中的深拷贝与浅拷贝
allen的博客
05-22 1万+
一、概念 1、深拷贝（Deep Copy） 拷贝的是数据本身，创造一个样的新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值。既然内存地址不同，释放内存地址时，可分别释放。 值类型的数据，默认全部都是深复制，Array、Int、String、Struct、Float，Bool。 2、浅拷贝（Shallow Copy） 拷贝的是数据地址，只复制指向的对象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也会变化。释放内
GO 浅拷贝和深拷贝
weixin_39171666的博客
05-20 3269
go 深度拷贝和浅拷贝
Golang中的深浅拷贝、结构体的拷贝、或可能的深拷贝失败原因
Ws_Te47的博客
01-05 1829
深拷贝：创建一个一样的新对象，新分配一块内存。新旧对象的修改操作互不影响。浅拷贝：只复制指向对象的指针，新旧对象依旧是同一块内存，修改时一起修改。
一文带你搞懂Go语言中深拷贝与浅拷贝
最新发布
做兴趣使然的Hero
03-11 1145
浅拷贝和深拷贝是Go语言中处理对象复制时的两种重要方式。它们的主要区别在于处理引用类型字段时的行为不同。理解数据结构的复制方式：在对数据进行拷贝操作时，要明确是进行浅拷贝还是深拷贝，以避免意外的数据共享或修改。避免数据共享带来的问题：当多个变量共享同一份数据时，一个变量的修改可能会影响其他变量。在需要独立操作数据时，应该使用深拷贝来复制数据。性能考虑：深拷贝通常比浅拷贝更耗时，因为需要复制整个数据结构。在处理大型数据集时，需要权衡性能和数据独立性。使用copy()函数进行切片拷贝。
golang-swaggerui-example:Golang的SwaggerUI生成示例
05-14
golang-swaggerui-example Golang-swaggerui-example是一个示例存储库，用于在您的Golang项目中使用SwaggerUI设置API文档。 详细说明可在。 API互动 可以通过访问localhost：8080 / swaggerui /访问SwaggerUI，有关...
golang-file-sever：用golang编写的性能文件服务器
02-12
在本文中，我们将深入探讨如何使用Golang构建一个高性能的文件服务器。Golang，也称为Go，是由Google开发的一种静态类型的、编译型的、并发的、垃圾回收的编程语言，特别适合构建网络服务和高性能应用程序。文件...
demoinfocs-golang:高性能CS
07-24
demoinfocs-golang - CS:GO 演示解析器用于解析和分析反恐精英：全球攻势 (CS:GO) 演示（又名回放）的极速、功能完整且可用于生产的 Go 库。 它基于和但提供了许多改进。讨论/聊天您可以使用或来提出问题并讨论有关...
pre-commit-golang:Golang的Pre-Commit钩子，支持模块
05-04
提交前GoLang 一组用于Golang的git pre-commit挂钩，支持模块。 需要挂钩管理框架。安装您可以将以下代码段复制/粘贴到.pre-commit-config.yaml文件中。 注意可以在找到更加充实的版本 # ==========================...
Go深拷贝和浅拷贝
ckckckcckckc的博客
02-16 351
go语言的深拷贝浅拷贝总结。
golang深度拷贝map
xtxy的专栏
07-06 2万+
最简单的方法是用json unmarshal，变成字符串，然后再用 json marshal生成新的map。这种方法对结构体也适用。 如果是map[string]interface{}和[]interface{}的组合，用代码递归也很简单： func DeepCopy(value interface{}) interface{} { if valueMap, ok := value.(map
golang切片和数组拷贝（浅拷贝和深拷贝）
西京刀客
10-22 7575
我们提到的深拷贝和浅拷贝，则指的是引用类型的值处理方案。数组和切片属于哪种？ 浅拷贝指的是，把变量里面存的内存地址拷贝了，所指向的真实值并没拷贝。
Golang 结构体struct 深浅拷贝
小楼一夜听春雨，深巷明朝卖杏花
02-09 4029
结构体浅拷贝和深拷贝 我们在开发中经常到把一个变量复制给另一个变量，那么这个过程，可能是深拷贝。 把一个变量赋值给新的变量的时候，可能涉及到深浅拷贝。 浅拷贝：复制的对象是指针，新老对象指向同一块内存区域，a修改字段，b中字段也跟着变了。内存销毁的时候也是一致的。 深拷贝：拷贝的是数据本身，会新创建一个对象，指向完全不同的内存地址，既然内存地址不同，那么修改也互不影响。 定义和区别 浅拷贝的是数据地址，只复制指向对象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也
【Go】深拷贝与浅拷贝
weixin_44211968的博客
02-27 3842
文章目录一、深浅拷贝二、深拷贝三、浅拷贝四、总结参考链接 一、深浅拷贝 在很多编程语言都有深浅拷贝的这个概念，当然golang也不例外。 在 go 语言中 值类型 赋值都是 深拷贝 ，引用类型 一般都是 浅拷贝。 其本质就是，深拷贝会拷贝数据（两变量存储地址不同，拷贝结束互不影响）。而浅拷贝只会拷贝内存的地址（即使拷贝结束，还是互相影响），所以就会出现，像 slice 那样修改底层数组的值，slice 的值也跟着改动。 二、深拷贝 b 拷贝 a 后，如果修改 a 的值，b不变，说明是值的拷贝，也就是深拷
Golang深拷贝浅拷贝
热门推荐
王佳宇的个人博客
05-30 3万+
Golang深拷贝浅拷贝 在了解原型设计模式之前我们需要新知道Golang的深拷贝与浅拷贝之间的区别。 推荐大家新看看Slice 和 Map那么常见的坑：https://blog.csdn.net/weixin_40165163/article/details/90707593 github:https://github.com/zhumengyifang/GolangDesignPatte...
go深拷贝和浅拷贝
小胡子
02-09 1553
go深拷贝和浅拷贝
Golang 引用类型的浅拷贝与深拷贝
wht1995316的博客
08-21 879
golang 浅拷贝与深拷贝
深入理解Go语言中的深拷贝与浅拷贝
m0_60368041的博客
09-02 519
摘要： 在Go语言中，值类型和引用类型的复制方式是通过深拷贝和浅拷贝来实现的。深拷贝会复制对象的所有值，而浅拷贝只会复制对象的引用。本文将深入探讨Go语言中深拷贝和浅拷贝的概念、区别以及使用场景。
go使用benchmark分析json库性能
小知识折射大智慧
11-12 1576
通过benchmark分析比较fastjson和simplejson的性能
使用Golang构建redis-cli：方法详解
"使用Golang编写Redis客户端工具redis-cli的示例教程" 本文将详细介绍如何使用Golang语言来实现一个简单的Redis命令行客户端（redis-cli）的示例。通过理解Redis的通信协议以及利用Golang的网络编程能力，我们可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

呆呆的猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值