Go语言复制库jinzhu/copier

最新推荐文章于 2023-11-12 21:03:59 发布
最新推荐文章于 2023-11-12 21:03:59 发布
阅读量1.8k 收藏
点赞数
分类专栏： golang 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30614345/article/details/131155410
版权

Go语言复制库jinzhu/copier

关于复制或深度克隆，Copier是一个很方便的工具。

当处理复杂的数据结构或嵌套结构时，手动复制数据可能会是一个繁琐且容易出错的任务。

Copier 在这种情况下非常有用。

Copier提供了一系列功能。

  • 从相同名称的字段复制到字段
  • 从具有相同名称的方法复制到字段
  • 从字段复制到具有相同名称的方法
  • 从切片复制到切片
  • 从结构体复制到切片
  • 从 map 复制到 map
  • 强制复制带有标记的字段
  • 忽略带有标记的字段
  • 深度复制

GitHub地址：https://github.com/jinzhu/copier

官方文档：https://pkg.go.dev/github.com/jinzhu/copier

1、安装

go get github.com/jinzhu/copier

2、官网综合例子

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name        string
	Role        string
	Age         int32
	EmployeCode int64 `copier:"EmployeNum"` // 指定字段名称
	Salary      int   // 在目标结构中显式忽略
}

func (user *User) DoubleAge() int32 {
	return 2 * user.Age
}

type Employee struct {
	// 必须复制,字段未复制则panic
	Name string `copier:"must"`
	// 必须复制,字段未复制则返回一个error
	Age int32 `copier:"must,nopanic"`
	// 显式忽略复制此字段
	Salary    int `copier:"-"`
	DoubleAge int32
	EmployeId int64 `copier:"EmployeNum"` // 指定字段名称
	SuperRole string
}

func (employee *Employee) Role(role string) {
	employee.SuperRole = "Super " + role
}

func main() {
	var (
		user      = User{Name: "Jinzhu", Age: 18, Role: "Admin", Salary: 200000}
		users     = []User{{Name: "Jinzhu", Age: 18, Role: "Admin", Salary: 100000}, {Name: "jinzhu 2", Age: 30, Role: "Dev", Salary: 60000}}
		employee  = Employee{Salary: 150000}
		employees = []Employee{}
	)
	copier.Copy(&employee, &user)
	/*
		Employee{
		   Name: "Jinzhu",           // Copy from field
		   Age: 18,                  // Copy from field
		   Salary:150000,            // Copying explicitly ignored
		   DoubleAge: 36,            // Copy from method
		   EmployeeId: 0,            // Ignored
		   SuperRole: "Super Admin", // Copy to method
		}
	*/
	// main.Employee{Name:"Jinzhu", Age:18, Salary:150000, DoubleAge:36, EmployeId:0, SuperRole:"Super Admin"}
	fmt.Printf("%#v \n", employee)

	// 复制struct到slice
	copier.Copy(&employees, &user)
	// []main.Employee{main.Employee{Name:"Jinzhu", Age:18, Salary:0, DoubleAge:36, EmployeId:0, SuperRole:"Super Admin"}}
	fmt.Printf("%#v \n", employees)

	// 复制slice到slice
	employees = []Employee{}
	copier.Copy(&employees, &users)
	// []
	// main.Employee{main.Employee{Name:"Jinzhu", Age:18, Salary:0, DoubleAge:36, EmployeId:0, SuperRole:"Super Admin"},
	// main.Employee{Name:"jinzhu 2", Age:30, Salary:0, DoubleAge:60, EmployeId:0, SuperRole:"Super Dev"}}
	fmt.Printf("%#v \n", employees)

	// 复制map到map
	map1 := map[int]int{3: 6, 4: 8}
	map2 := map[int32]int8{}
	copier.Copy(&map2, map1)
	// map[int32]int8{3:6, 4:8}
	fmt.Printf("%#v \n", map2)
}

3、高级特性

3.1 方法赋值

目标对象中的一些字段，源对象中没有，但是源对象有同名的方法。这时 Copy 会调用这个方法，将返回值赋值给

目标对象中的字段。

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name string
	Age  int
}

func (u *User) DoubleAge() int {
	return 2 * u.Age
}

type Employee struct {
	Name      string
	DoubleAge int
	Role      string
}

func main() {
	user := User{Name: "dj", Age: 18}
	employee := Employee{}
	copier.Copy(&employee, &user)
	// main.Employee{Name:"dj", DoubleAge:36, Role:""}
	fmt.Printf("%#v\n", employee)
}

我们给User添加一个DoubleAge方法，Employee结构有字段DoubleAge，User中没有，但是User有一个同名的

方法，这时Copy调用user的DoubleAge方法为employee的DoubleAge赋值，得到 36。

3.2 调用目标方法

有时候源对象中的某个字段没有出现在目标对象中，但是目标对象有一个同名的方法，方法接受一个同类型的参

数，这时 Copy 会以源对象的这个字段作为参数调用目标对象的该方法。

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name string
	Age  int
	Role string
}

type Employee struct {
	Name      string
	Age       int
	SuperRole string
}

func (e *Employee) Role(role string) {
	e.SuperRole = "Super" + role
}

func main() {
	user := User{Name: "dj", Age: 18, Role: "Admin"}
	employee := Employee{}
	copier.Copy(&employee, &user)
	// main.Employee{Name:"dj", Age:18, SuperRole:"SuperAdmin"}
	fmt.Printf("%#v\n", employee)
}

我们给Employee添加了一个Role方法，User的字段Role没有出现在Employee中，但是Employee有一个同名方

法。Copy函数内部会以user对象的Role字段为参数调用employee的Role方法。最终，我们的employee对象的

SuperRole值变为SuperAdmin。实际上，这个方法中可以执行任何操作，不一定是赋值。

3.3 切片赋值

使用一个切片来为另一个切片赋值。如果类型相同，那好办，直接append就行。如果类型不同，copier就派上

大用场了。

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name string
	Age  int
}

type Employee struct {
	Name string
	Age  int
	Role string
}

func main() {
	users := []User{
		{Name: "dj", Age: 18},
		{Name: "dj2", Age: 18},
	}
	employees := []Employee{}
	copier.Copy(&employees, &users)
	// []main.Employee{main.Employee{Name:"dj", Age:18, Role:""}, main.Employee{Name:"dj2", Age:18, Role:""}}
	fmt.Printf("%#v\n", employees)
}

这个实际上就是将源切片中每个元素分别赋值到目标切片中。

3.4 将结构赋值到切片

这个不难，实际上就是根据源对象生成一个和目标切片类型相符合的对象，然后 append 到目标切片中。

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name string
	Age  int
}

type Employee struct {
	Name string
	Age  int
	Role string
}

func main() {
	user := User{Name: "dj", Age: 18}
	employees := []Employee{}
	copier.Copy(&employees, &user)
	// []main.Employee{main.Employee{Name:"dj", Age:18, Role:""}}
	fmt.Printf("%#v\n", employees)
}

上面代码中，Copy先通过user生成一个Employee对象，然后append到切片employees中。

3.5 结构体复制

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name string
	Age  int
}

type Employee struct {
	Name string
	Age  int
	Role string
}

func main() {
	user := User{Name: "dj", Age: 18}
	employee := Employee{}
	copier.Copy(&employee, &user)
	// main.Employee{Name:"dj", Age:18, Role:""}
	fmt.Printf("%#v\n", employee)
}

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name     string
	Age      int
	Email    string
	Password string
}

type SimpleUser struct {
	Name string
	Age  int
}

func main() {
	user := User{
		Name: "Aiden",
		Age: 30,
		Email: "aidenlee@gmail.com",
		Password: "thisisasecret",
	}
	s := SimpleUser{}
	copier.Copy(&s, &user)
	// main.SimpleUser{Name:"Aiden", Age:30}
	fmt.Printf("%#v\n", s)
}

3.6 汇总

最后将所有的特性汇总在一个例子中，其实就是 Copier 的 GitHub 仓库首页的例子。

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name string
	Age  int
	Role string
}

func (u *User) DoubleAge() int {
	return u.Age * 2
}

type Employee struct {
	Name      string
	Age       int
	SuperRole string
}

func (e *Employee) Role(role string) {
	e.SuperRole = "Super" + role
}

func main() {
	var (
		user  = User{Name: "dj", Age: 18}
		users = []User{
			{Name: "dj", Age: 18, Role: "Admin"},
			{Name: "dj2", Age: 18, Role: "Dev"},
		}
		employee  = Employee{}
		employees = []Employee{}
	)

	copier.Copy(&employee, &user)
	// main.Employee{Name:"dj", Age:18, SuperRole:"Super"}
	fmt.Printf("%#v\n", employee)

	copier.Copy(&employees, &user)
	// []main.Employee{main.Employee{Name:"dj", Age:18, SuperRole:"Super"}}
	fmt.Printf("%#v\n", employees)

	employees = []Employee{}
	copier.Copy(&employees, &users)
	// []main.Employee{main.Employee{Name:"dj", Age:18, SuperRole:"SuperAdmin"}, main.Employee{Name:"dj2", Age:18, SuperRole:"SuperDev"}}
	fmt.Printf("%#v\n", employees)
	// 2
	fmt.Printf("%d",len(employees))
}

3.7 带选项复制

copier.CopyWithOption(&to, &from, copier.Option{IgnoreEmpty: true, DeepCopy: true})

package main

import (
	"fmt"
	"github.com/jinzhu/copier"
)

type User struct {
	Name     string
	Age      int
	Email    string
	Password string
}

type SimpleUser struct {
	Name string
	Age  int
}

func main() {
	user1 := User{
		Name:     "Aiden",
		Age:      30,
		Email:    "aidenlee@gmail.com",
		Password: "thisisasecret",
	}
	s1 := SimpleUser{}
	copier.CopyWithOption(&s1, &user1, copier.Option{IgnoreEmpty: true, DeepCopy: true})
	s1.Name = "Tom"
	// main.SimpleUser{Name:"Tom", Age:30}
	fmt.Printf("%#v\n", s1)
	// main.User{Name:"Aiden", Age:30, Email:"aidenlee@gmail.com", Password:"thisisasecret"}
	fmt.Printf("%#v\n", user1)

	user2 := User{
		Name:     "Aiden",
		Age:      30,
		Email:    "aidenlee@gmail.com",
		Password: "thisisasecret",
	}
	s2 := SimpleUser{}

	copier.CopyWithOption(&s2, &user2, copier.Option{IgnoreEmpty: true, DeepCopy: false})
	s2.Name = "Tom"
	// main.SimpleUser{Name:"Tom", Age:30}
	fmt.Printf("%#v\n", s2)
	// main.User{Name:"Aiden", Age:30, Email:"aidenlee@gmail.com", Password:"thisisasecret"}
	fmt.Printf("%#v\n", user2)
}
242030
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
整理一篇golang常用的三方库
qq_39272466的博客
10-13 322
golang的每日一库，加快你的开发速度，玩golang的一定要看看，让你的代码更加简洁，追求1行代码解决问题，joker会持续更新……...
Go源码解析：copier库
了凡的博客
01-06 2288
注：该文章源码分析参考copier 目录 源码包 代码阅读 1、tag标签说明 2、静态参数 3、整体设计 4、辅助方法说明 I、获取实际的Type和Value II、Tag处理 III、获取结构体Field切片 IV、检查结构体复制结果 V、对结构体进行设值 5、Copy主方法说明 I、参数说明 II、不可寻址 III、非Valid IV、可转换结构体的转换 V、两个类型都是map的处理 VI、只有一个类型是结构体的处理 VII、判断数组设置标识 VIII、根据.
go包github.com/jinzhu/copier
qq_40530622的博客
09-09 607
package main import ( "fmt" "time" "github.com/jinzhu/copier" ) // 结构体赋值 // go get -u github.com/jinzhu/copier func main() { in := Info2{ ID: 1, LastModificationTime: time.Now(), } in2 := &Info{} copier.Copy(in2, in) f
golang库之copier
小白菜的专栏
04-04 2718
github地址 https://github.com/jinzhu/copier 简介 调用同名方法为字段赋值； 以源对象字段为参数调用目标对象的方法，从而为目标对象赋值（当然也可以做其它的任何事情）； 将切片赋值给切片（可以是不同类型哦）； 将结构体追加到切片中。 使用 package main import ( "fmt" "github.com/jinzhu/copier"...
golang结构体拷贝jinzhu/copier
yantao_1994的博客
03-23 349
【代码】golang结构体拷贝jinzhu/copier。
golang Copier 数据复制
最新发布
weixin_39064001的博客
11-12 1227
整体来说，copier能满足我们日常业务开发中的大部分场景，而且可以有效的解耦数据结构之间的依赖，通过一种低耦合的方式，实现数据复制任务
复印机：golang复印机，将值从struct复制到struct等
02-02
"github.com/jinzhu/copier" ) type User struct { Name string Role string Age int32 // Explicitly ignored in the destination struct. Salary int } func ( user * User ) DoubleAge () int32 { return ...
开源项目-jinzhu-gorm.zip
10-28
Gorm，由Jinzhu开发的一个开源项目，是Go语言中广泛使用的ORM（对象关系映射）库，它的出现极大地简化了Go开发者处理数据库关系的工作。"开源项目-jinzhu-gorm.zip"这个压缩包包含了Gorm的源码，为开发者提供了深入...
configor：支持YAML，JSON，TOML，Shell环境的Golang配置工具
02-03
支持YAML，JSON，TOML，Shell环境的Golang配置工具（支持Go 1.10+） 用法 package main import ( "fmt" "github.com/jinzhu/configor" ) var Config = struct { APPName string `default:"app name"` DB struct ...
windows下的go语言的websocket库
01-12
在Windows环境下，Go语言（Golang）开发Websocket应用时，可以借助多个开源库来实现。Websocket是一种在客户端和服务器之间建立长连接的协议，它允许双方进行实时、双向通信，非常适合于需要实时交互的应用场景，如...
copier, 用于golang的复印机，从结构到结构的复制值.zip
10-10
copier, 用于golang的复印机，从结构到结构的复制值 复印机我是复印机，从一个到另一个复制所有东西。特性使用相同名称将字段复制到字段从方法复制到具有相同名称的字段从字段复制到具有相同名称的方法从切片复制到切片从结构复制到切片用法package maini
Go-Deepcopier-golang的简单结构复制
08-13
Deepcopier - golang的简单结构复制
go-clone：深度克隆任何Go数据
01-28
go-clone：深度克隆任何Go数据 包clone提供了对任何Go数据进行深度克隆的功能。 它还提供了一个包装器，以保护指针免受任何意外的突变。 Clone / Slowly可以克隆任何结构的未导出字段。 明智地使用此功能。 安装 使用go get安装此软件包。 go get github.com/huandu/go-clone 用法 Slowly Clone 如果要克隆任何Go值，请使用Clone 。 t := & T { ... } v := clone . Clone ( t ).( * T ) reflect . DeepEqual ( t , v ) // true 为了性能起见， Clone不处理包含指针周期的值。 如果我们需要克隆此类值，请改用Slowly 。 type ListNode struct { Data int Next * ListNode } node1 := & ListNode { Data : 1 , } node2 := & ListNode { Data : 2 , } node3 := & Lis
yugo:Go语言web后端框架 | Yugo Go Web Framework
05-11
路由使用 gorilla/mux csrf保存 gorilla/csrf session操作 gorilla/sessions 模板引擎使用 CloudyKit/jet 开发时热加载使用 pilu/fresh 数据库ORM jinzhu/gorm
「GoCN酷Go推荐」万能的对象拷贝工具——Copier
Go中国
03-14 2755
推荐理由在DDD的领域驱动的设计之下，数据流向由DTO到DO再到PO，在Golang语言中，不同类型的转换由独立的函数或者方法来实现。随着对象类型的增加，对象字段的增加以及复杂化，各种类型...
golang一个深复制的库
weixin_30731305的博客
09-18 74
https://github.com/mitchellh/copystructure 转载于:https://www.cnblogs.com/ziyouchutuwenwu/p/4820632.html
copier库golang中的dto库
lvpeng6的博客
09-28 422
欢迎大佬指点，讨论。
Go 几种深度克隆方式
王小明的专栏
12-23 887
Java 深度克隆 /深度克隆，可以克隆任意数据类型 func DeepClone(src interface{}) (interface{}, error) { typ := reflect.TypeOf(src) if typ.Kind() == reflect.Ptr { typ = typ.Elem() dst := reflect.New(typ).Elem() b, _ := json.Marshal(src) if err := json.Unmarshal(b, dst
Golang数据库jinzhu框架使用
楊帥
01-15 1346
文档地址 数据模型 //Account 储存数据结构 type Account struct { ID int `gorm:"primary_key"` AccountIP string `gorm:"type:varchar(100);not null"` AccountNum int32 `gorm:"type:int;not...
golang如何创建数据库
10-27
在golang中，我们可以使用第三方库gorm来创建数据库。具体步骤如下： 1. 首先需要安装gorm库，可以使用命令`go get -u github.com/jinzhu/gorm`来安装。 2. 在代码中引入gorm库，`import "github.com/jinzhu/gorm"` 3. 在代码中创建数据库连接池，可以参考以下代码： ``` import ( "fmt" "github.com/jinzhu/gorm" _ "github.com/go-sql-driver/mysql" ) func InitDB() *gorm.DB { // 数据库连接信息 db, err := gorm.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8&parseTime=True&loc=Local") if err != nil { fmt.Println("fail err mysql", err.Error()) } // 自动创建表 db.AutoMigrate(&User{}) return db } ``` 4. 在代码中获取数据库连接池实例，可以参考以下代码： ``` func GetDB() *gorm.DB { return DB } ``` 需要注意的是，在创建数据库连接池时，需要提供数据库连接信息，包括用户名、密码、主机地址、端口号、数据库名称等。同时，我们还需要在代码中定义数据库模型，以便于gorm自动创建表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值