golang 对象深拷贝的常见方式及性能

目录
  • 关于golang拷贝的概念
  • 完整代码
  • 总结

关于golang拷贝的概念

Go语言中所有赋值操作都是值传递,如果结构中不含指针,则直接赋值就是深度拷贝;如果结构中含有指针(包括自定义指针,以及切片,map等使用了指针的内置类型),则数据源和拷贝之间对应指针会共同指向同一块内存,这时深度拷贝需要特别处理。目前,有三种方法,一是用gob序列化成字节序列再反序列化生成克隆对象;二是先转换成json字节序列,再解析字节序列生成克隆对象;三是针对具体情况,定制化拷贝。前两种方法虽然比较通用但是因为使用了reflex反射,性能比定制化拷贝要低出2个数量级,所以在性能要求较高的情况下应该尽量避免使用前两者。

完整代码

package json
import (
   "bytes"
   "encoding/gob"
   "encoding/json"
   "fmt"
   "testing"
)
/**
 * @Description: 请求信息
 */
type BidRequest struct {
   ID     string  `json:"id"`
   Imp    []*Imp  `json:"imp"`
   Device *Device `json:"device"`
}
/**
 * @Description: imp对象
 */
type Imp struct {
   ID          string  `json:"id"`
   Tagid       string  `json:"tagid"`
   Bidfloor    float64 `json:"bidfloor"`
}
/**
 * @Description: 设备信息
 */
type Device struct {
   Ua         string `json:"ua"`
   IP         string `json:"ip"`
   Geo        *Geo   `json:"geo"`
   Make       string `json:"make"`
   Model      string `json:"model"`
   Os         string `json:"os"`
   Osv        string `json:"osv"`
}
/**
 * @Description: 地理位置信息
 */
type Geo struct {
   Lat     int    `json:"lat"`
   Lon     int    `json:"lon"`
   Country string `json:"country"`
   Region  string `json:"region"`
   City    string `json:"city"`
}
/**
 * @Description: 利用gob进行深拷贝
 */
func DeepCopyByGob(src,dst interface{}) error {
   var buffer bytes.Buffer
   if err := gob.NewEncoder(&buffer).Encode(src); err != nil {
      return err
   }
   return gob.NewDecoder(&buffer).Decode(dst)
}
/**
 * @Description: 利用json进行深拷贝
 */
func DeepCopyByJson(src,dst *BidRequest) error{
   if tmp, err := json.Marshal(&src);err!=nil{
      return err
   }else {
      err = json.Unmarshal(tmp, dst)
      return err
   }
}

/**
 * @Description: 通过自定义进行copy
 */
func DeepCopyByCustom(src,dst *BidRequest){
   dst.ID=src.ID
   dst.Device=&Device{
      Ua: src.Device.Ua,
      IP: src.Device.IP,
      Geo: &Geo{
         Lat: src.Device.Geo.Lat,
         Lon: src.Device.Geo.Lon,
      },
      Make: src.Device.Make,
      Model: src.Device.Model,
      Os: src.Device.Os,
      Osv: src.Device.Osv,
   }
   dst.Imp=make([]*Imp,len(src.Imp))
   for index,imp:=range src.Imp{
      //注意此处因为imp对象里无指针对象,所以可以直接使用等于
      dst.Imp[index]=imp
   }
}

func initData()*BidRequest  {
   str:="{"id":"MM7dIXz4H05qtmViqnY5dW","imp":[{"id":"1","tagid":"3979722720","bidfloor":0.01}],"device":{"ua":"Mozilla/5.0 (Linux; Android 10; SM-G960N Build/QP1A.190711.020; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.115 Mobile Safari/537.36 (Mobile; afma-sdk-a-v212621039.212621039.0)","ip":"192.168.1.0","geo":{"lat":0,"lon":0,"country":"KOR","region":"KR-11","city":"Seoul"},"make":"samsung","model":"sm-g960n","os":"android","osv":"10"}}"
   ans:=new(BidRequest)
   json.Unmarshal([]byte(str),&ans)
   return ans
}

/**
 * @Description: 压测深拷贝 -gob
 */
func BenchmarkDeepCopy_Gob(b *testing.B)  {
   src:=initData()
   b.ResetTimer()
   for i:=0;i<b.N;i++{
      DeepCopyByGob(src,new(BidRequest))
   }
}

/**
 * @Description: 压测深拷贝 -json
 */
func BenchmarkDeepCopy_Json(b *testing.B)  {
   src:=initData()
   b.ResetTimer()
   for i:=0;i<b.N;i++{
      DeepCopyByJson(src,new(BidRequest))
   }
}
/**
 * @Description: 压测深拷贝 -custom
 */
func BenchmarkDeepCopy_custom(b *testing.B)  {
   src:=initData()
   b.ResetTimer()
   for i:=0;i<b.N;i++{
      DeepCopyByCustom(src,new(BidRequest))
   }
}
/**
 * @Description: 测试拷贝是否ok
 */
func TestCpoyIsOk(t *testing.T)  {
   src:=initData()
   //1.gob
   dst01:=new(BidRequest)
   DeepCopyByGob(src,dst01)
   bs01, _ := json.Marshal(dst01)
   fmt.Printf("%v\n",string(bs01))
   //2.json
   dst02:=new(BidRequest)
   DeepCopyByJson(src,dst02)
   bs02, _ := json.Marshal(dst02)
   fmt.Printf("%v\n",string(bs02))
   //3.custom
   dst03:=new(BidRequest)
   DeepCopyByCustom(src,dst03)
   bs03, _ := json.Marshal(dst02)
   fmt.Printf("%v\n",string(bs03))
}

先执行 TestCpoyIsOk,验证三种方式的输出是否ok,其验证结果如下:

benmark三种copy方式:

执行命令 go test -bench=. -benchmem 可以同时查看到每次操作的内存和耗时的情况

总结

可以看到 从性能上来讲 custom>json>gob,从代码数量上来讲 gob>json>custom ,因此具体使用时应该充分考虑性能和代码复杂度,若性能要求不是很高建议gob方法,其比较简洁并且利于生成工具包,若要求性能则尽量使用custom,此处不偷懒可以提高性能哦。若是性能要求在中间,则可以使用json先序列化,再反序列化赋值。

到此这篇关于golang 对象深拷贝的常见方式及性能的文章就介绍到这了,更多相关golang 深拷贝内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • golag 使用sort.slice包实现对象list排序

    目录 1.sort.Sort介绍 1.1分析内置sort包 1.2分析sort.go 2.使用方法 2.1基础类型排序 2.2对象排序(单一字段) 2.3对象排序(多字段) 3.sort.Slice介绍 3.1使用方法 3.2运行 1.sort.Sort介绍 使用sort.Slice进行排序,因为slice把struct抽象化了,且slice封装过了,简单的基础类型可以使用sort,使用sort排序需要重写三个interface,不想学习sort排序的可以直接看第三步 这里将对比sort跟sli

  • golang中接口对象的转型两种方式

    接口对象的转型有两种方式: 1. 方式一:instance,ok:=接口对象.(实际类型) 如果该接口对象是对应的实际类型,那么instance就是转型之后对象,ok的值为true 配合if...else if...使用 2. 方式二: 接口对象.(type) 配合switch...case语句使用 示例: package main import ( "fmt" "math" ) type shape interface { perimeter() int area

  • golang gorm的Callbacks事务回滚对象操作示例

    目录 1. Callbacks 1.1. 创建对象 1.2. 更新对象 1.3. 删除对象 1.4. 查询对象 1.5. 回调示例 1. Callbacks 您可以将回调方法定义为模型结构的指针,在创建,更新,查询,删除时将被调用,如果任何回调返回错误,gorm将停止未来操作并回滚所有更改. 1.1. 创建对象 创建过程中可用的回调 // begin transaction 开始事物 BeforeSave BeforeCreate // save before associations 保存前关

  • golang遍历时修改被遍历对象的示例详解

    前言 很多时候需要将遍历对象中去掉某些元素,或者往遍历对象中添加元素,这时候就需要小心操作了. 对于go语言中的一些注意事项我做了总结和示例,留下点笔记. 遍历切片 1.遍历切片时去掉元素,错误示例: func main() { arr := []int{1, 2, 3, 4} for i := range arr { if arr[i] == 3 { arr = append(arr[:i], arr[i+1:]...) } } fmt.Println(arr) } 最终报错panic: ru

  • golang 如何通过反射创建新对象

    废话少说,直接贴代码~ type A struct { Name string } // 测试unit func TestReflect(t *testing.T) { reflectNew((*A)(nil)) } //反射创建新对象. func reflectNew(target interface{}) { if target == nil { fmt.Println("参数不能未空") return } t := reflect.TypeOf(target) if t.Kind

  • golang 对象深拷贝的常见方式及性能

    目录 关于golang拷贝的概念 完整代码 总结 关于golang拷贝的概念 Go语言中所有赋值操作都是值传递,如果结构中不含指针,则直接赋值就是深度拷贝:如果结构中含有指针(包括自定义指针,以及切片,map等使用了指针的内置类型),则数据源和拷贝之间对应指针会共同指向同一块内存,这时深度拷贝需要特别处理.目前,有三种方法,一是用gob序列化成字节序列再反序列化生成克隆对象:二是先转换成json字节序列,再解析字节序列生成克隆对象:三是针对具体情况,定制化拷贝.前两种方法虽然比较通用但是因为使用

  • 详解C#实例化对象的三种方式及性能对比

    前言 做项目过程中有个需求要实例化两万个对象并添加到List 中,这个过程大概需要1min才能加载完(传参较多),于是开启了代码优化之旅,再此记录. 首先想到的是可能实例化比较耗时,于是开始对每种实例化方式进行测试,过程如下 实例化方式 1.用 New 关键字实例化一个类 2.用 Activator 实例化一个类 3.用 Assembly 实例化一个类 代码实现 测试环境: vs2019 .NET Framework 4.7 Intel Core i7-10510U CPU 首先定义一个类Per

  • Vue指令v-for遍历输出JavaScript数组及json对象的常见方式小结

    本文实例讲述了Vue指令v-for遍历输出JavaScript数组及json对象的常见方式.分享给大家供大家参考,具体如下: 定义数据: <script> new Vue({ el:"#test", data:{ message:"infor", list:["a","b","c","d","e"], web:{ "百度":"

  • 三种Golang数组拷贝方式及性能分析详解

    目录 测试 测试代码 测试结果 原理分析 copy append 总结 在Go语言中,我们可以使用for.append()和copy()进行数组拷贝,对于某些对性能比较敏感且数组拷贝比较多的场景,我们可以会对拷贝性能比较关注,这篇文件主要是对比一下这三种方式的性能. 测试 测试条件是把一个64KB的字节数组分为64个块进行复制. 测试代码 package test import ( "testing" ) const ( blocks = 64 blockSize = 1024 ) v

  • 详解C#通过反射获取对象的几种方式比较

    目录 使用标准反射的 Invoke 方法 使用 Activator.CreateInstance 使用 Microsoft.Extensions.DependencyInjection Natasha 使用表达式 Expression 使用 Emit 对比测试 总结 相关链接 在本文中,对比了常见的几种反射的方法,介绍了它们分别应该如何使用,每种的简易度和灵活度,然后做了基准测试,一起看看这之间的性能差距. 按照使用的简易度和灵活度,做了下边的排序,可能还有一些其他的反射方式,比如 Source

  • java 单例的五种实现方式及其性能分析

    java 单例的五种实现方式及其性能分析 序言 在23种设计模式中,单例是最简单的设计模式,但是也是很常用的设计模式.从单例的五种实现方式中我们可以看到程序员对性能的不懈追求.下面我将分析单例的五种实现方式的优缺点,并对其在多线程环境下的性能进行测试. 实现 单例模式适用于资源占用较多的类,保证一个类只有一个实例即单例.通用的做法就是构造器私有化,提供一个全局的访问点,返回类的实例. uml图: 1.饿汉式 代码实现: package com.zgh.gof23.singleton; /** *

  • 浅谈JS中的三种字符串连接方式及其性能比较

    工作中经常会碰到要把2个或多个字符串连接成一个字符串的问题,在JS中处理这类问题一般有三种方法,这里将它们一一列出顺便也对它们的性能做个具体的比较. 第一种方法 用连接符"+"把要连接的字符串连起来: str="a"; str+="b"; 毫无疑问,这种方法是最便捷快速的,如果只连接100个以下的字符串建议用这种方法最方便. 第二种方法 以数组作为中介用 join 连接字符串: var arr=new Array(); arr.push(a);

  • 详解JS几种变量交换方式以及性能分析对比

    前言 "两个变量之间的值得交换",这是一个经典的话题,现在也有了很多的成熟解决方案,本文主要是列举几种常用的方案,进行大量计算并分析对比. 起由 最近做某个项目时,其中有一个需求是交换数组中的两个元素.当时使用的方法是: arr = [item0,item1,...,itemN]; //最初使用这段代码来交换第0个和第K(k<N)个元素 arr[0] = arr.splice(k, 1, arr[0])[0]; 当时觉得这种方法很优雅,高逼格... 后来,业余时间又拿这个研究下了

  • C#引用类型转换的常见方式总结

    本文以实例形式简单讲述了引用类型转换的几种常见方式,如:子类转换成父类,父类转换成子类,以及不是子父级关系类之间的转换.现分述如下,供大家参考: 一.隐式转换:子类转换成父类 public class Animal { public int _age; public Animal(int age) { this._age = age; } } public class Dog : Animal { public float _weight; public Dog(float weight, in

  • Javascript三种字符串连接方式及性能比较

    第一种:用连接符"+"连接字符串 str="a"; str+="b"; 这种方法相对以下两种,最便捷快速.建议100字符以下的连接使用这种连接方式. 第二种:以数组作为中介,使用jion函数进行连接 var arr=new Array(); arr.push(a); arr.push(b); var str=arr.join(""); 第三种:利用对象属性连接字符串 function stringConnect(){ this

随机推荐