GO 浅拷贝和深拷贝

最新推荐文章于 2024-03-11 23:11:34 发布
最新推荐文章于 2024-03-11 23:11:34 发布
阅读量3k 收藏 2
点赞数
分类专栏： GO # GO优化 文章标签： golang 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39171666/article/details/130783855
版权

深浅本质区别

  • 是否真正获取到了被拷贝对象的单独掌控权，而不会产生互相影响的问题！

深拷贝（Deep Copy）

定义

  • 拷贝之后互不影响，即深可以理解为完全拷贝！
  • 拷贝的是数据本身，创造一个一样的新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值。既然内存地址不同，释放内存地址时，可分别释放。
  • 这样就不会产生引用问题，导致GC无法回收，也不会导致内存泄露问题！
  • 如果结构中不含指针，则直接赋值就是深度拷贝；

值类型的数据，默认全部都是深复制，Array、Int、String、Struct、Float，Bool。

什么时候需要深拷贝

在函数中需要更改结构体变量内容而对函数外的变量不产生影响时，需要深拷贝。

示例：

值类型就是深拷贝

/*
 * @Description:
 * @version:
 * @Author: Steven
 * @Date: 2022-10-10 23:44:53
 */
package main

import "fmt"

func main() {
    var it int = 20
    ita := it
    fmt.Println(it, ita)
    ita = 30
    fmt.Println(it, ita)
    it = 40
    fmt.Println(it, ita)
}

浅拷贝（Shallow Copy）

定义

  • 拷贝之后互相影响，即浅拷贝可以理解为只拷贝了一部分，比如引用类型，只会拷贝指向的底层数据指针，并不会拷贝底层数据！
  • 即拷贝对象和被拷贝对象指向的内存地址是一样的，所以会互相影响！只有都被释放时，才会同时释放内存地址。
  • 浅拷贝会引起内存泄露、GC不能回收等问题！
  • 如果结构体中含有指针（包括自定义指针，以及切片，map等使用了指针的内置类型），则数据源和拷贝之间对应指针会共同指向同一块内存，这时如果想深度拷贝需要特别处理。
  • 引用类型的数据，默认全部都是浅复制，Slice，Map

什么时候需要浅拷贝

很明显，仅当我们想让两个变量的修改互相被影响时，才使用浅拷贝，其他任何情况都应该使用深拷贝！

示例

  • 直接将引用类型变量赋值给另一个变量，属于浅拷贝
  • 将引用类型变量作为实参传给函数，也属于浅拷贝
  • append，不扩容的话也属于浅拷贝
  • copy拷贝的切片中的元素，如果元素是引用类型，那么此时也属于浅拷贝！

将一个引用类型变量赋值给另一个变量

/*
 * @Description:
 * @version:
 * @Author: Steven
 * @Date: 2022-10-10 23:44:53
 */
package main

import "fmt"

func main() {
    var sl []int = make([]int, 3, 4)
    fmt.Println("sl=", sl)   //sl= [0 0 0]
    sla := sl                //这就属于浅拷贝
    fmt.Println("sla=", sla) //sla= [0 0 0]
    sla[0] = 2
    sl[1] = 4
    fmt.Printf("sl: 为该变量分配的地址为=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl)
    fmt.Printf("sla: 为该变量分配的地址为=%p;指向内存地址=%p;值=%v\n", &sla, sla, sla)
}

运行结果：

sl= [0 0 0]
sla= [0 0 0]
sl: 为该变量分配的地址为=0xc000092060;指向内存地址=0xc0000a4060;值=[2 4 0]
sla: 为该变量分配的地址为=0xc000092090;指向内存地址=0xc0000a4060;值=[2 4 0]

new也属于浅拷贝

/*
 * @Description:
 * @version:
 * @Author: Steven
 * @Date: 2022-10-10 23:44:53
 */
package main

import "fmt"

func main() {
    var sl []int = make([]int, 3, 4)
    fmt.Println("sl=", sl) //sl= [0 0 0]
    sla := new([]int)
    *sla = sl                //这就属于浅拷贝
    //sla = &sl和*sla = sl等价的
    fmt.Println("sla=", sla) //sla= [0 0 0]
    (*sla)[0] = 2
    sl[1] = 4
    fmt.Printf("sl: 为该变量分配的地址为=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl)
    fmt.Printf("sla: 为该变量分配的地址为=%p;指向内存地址=%p;值=%v\n", &sla, *sla, sla)
}

sl= [0 0 0]
sla= &[0 0 0]
sl: 为该变量分配的地址为=0xc000008078;指向内存地址=0xc00000e1e0;值=[2 4 0]
sla: 为该变量分配的地址为=0xc00000a030;指向内存地址=0xc00000e1e0;值=&[2 4 0]

Copy

元素类型为值类型(深拷贝)

/*
 * @Description:
 * @version:
 * @Author: Steven
 * @Date: 2022-10-10 23:44:53
 */
package main

import "fmt"

func main() {
    var sl []int = make([]int, 3, 4)
    sl[0] = 20
    sl[1] = 200
    sl[2] = 2000
    cpSl := make([]int, len(sl))//由于元素类型为值类型，所以这里是深度拷贝
    copy(cpSl, sl)
    fmt.Printf("sl: 为该变量分配的地址为=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl)
    fmt.Printf("cpSl: 为该变量分配的地址为=%p;指向内存地址=%p;值=%v\n", &cpSl, cpSl, cpSl)
}

运行结果：很明显指向的内存地址不是一个！ 


D:\GOMOD\hello>go run hello.go
sl: 为该变量分配的地址为=0xc000008078;指向内存地址=0xc00000e1e0;值=[20 200 2000]
cpSl: 为该变量分配的地址为=0xc000008090;指向内存地址=0xc000010210;值=[20 200 2000]

元素类型为引用类型(浅拷贝)

/*
 * @Description:
 * @version:
 * @Author: Steven
 * @Date: 2022-10-10 23:44:53
 */
package main

import "fmt"

func main() {
    var sl [][]int = make([][]int, 3, 4)
    sl[0] = make([]int, 1, 2)
    sl[0] = []int{1}
    sl[1] = make([]int, 1)
    sl[1] = []int{2}
    sl[2] = make([]int, 1)
    sl[2] = []int{3}
    cpSl := make([][]int, len(sl)) //由于元素类型为引用类型，所以这里是浅拷贝
    copy(cpSl, sl)
    //由于是二维切片,此时sl 通过%p获取的是系统为第二维的切片值分配的内存地址，而不是最终指向数据的地址
    //&sl获取到的系统为变量sl分配的内存地址
    //&sl[0]和sl通过%p获取的地址都是为了保存第二维的切片又开辟的一个内存空间的地址，即[][]int，为了保存后面的[]int数据而开辟的空间
    //sl[0]通过%p获取到的地址才是一个内存空间地址，指向的数据类型为Int的数组，具体指向的是数组的第一个元素
    fmt.Printf("sl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl[0], sl)
    fmt.Printf("cpSl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &cpSl, cpSl, cpSl[0], cpSl)
    sl[0][0] = 11
    fmt.Printf("sl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl[0], sl)
    fmt.Printf("cpSl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &cpSl, cpSl, cpSl[0], cpSl)
    cpSl[1][0] = 22
    fmt.Printf("sl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl[0], sl)
    fmt.Printf("cpSl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &cpSl, cpSl, cpSl[0], cpSl)
}

运行结果：

sl: 为该变量分配的地址为=0xc000008078;第一个元素切片的地址=0xc000060060;指向内存地址=0xc00001a098;值=[[1] [2] [3]]
cpSl: 为该变量分配的地址为=0xc000008090;第一个元素切片的地址=0xc000062050;指向内存地址=0xc00001a098;值=[[1] [2] [3]]
sl: 为该变量分配的地址为=0xc000008078;第一个元素切片的地址=0xc000060060;指向内存地址=0xc00001a098;值=[[11] [2] [3]]
cpSl: 为该变量分配的地址为=0xc000008090;第一个元素切片的地址=0xc000062050;指向内存地址=0xc00001a098;值=[[11] [2] [3]]
sl: 为该变量分配的地址为=0xc000008078;第一个元素切片的地址=0xc000060060;指向内存地址=0xc00001a098;值=[[11] [22] [3]]
cpSl: 为该变量分配的地址为=0xc000008090;第一个元素切片的地址=0xc000062050;指向内存地址=0xc00001a098;值=[[11] [22] [3]]
  • 很明显最终指向数组内存空间的地址是一个
  • 而我们分别修改两个变量都会彼此影响

如何解决上面引用类型浅拷贝问题呢

化简为繁，我们依次拷贝二维切片第二维的每一个元素！

/*
 * @Description:
 * @version:
 * @Author: Steven
 * @Date: 2022-10-10 23:44:53
 */
package main

import "fmt"

func main() {
    var sl [][]int = make([][]int, 3, 4)
    sl[0] = make([]int, 1, 2)
    sl[0] = []int{1}
    sl[1] = make([]int, 1)
    sl[1] = []int{2}
    sl[2] = make([]int, 1)
    sl[2] = []int{3}
    cpSl := make([][]int, len(sl)) //由于元素类型为引用类型，所以这里是浅拷贝
    
    for k, v := range sl {//依次拷贝！
        cpSl[k] = make([]int, len(v))
        copy(cpSl[k], v)
    }
    //copy(cpSl, sl)
    fmt.Printf("sl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl[0], sl)
    fmt.Printf("cpSl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &cpSl, cpSl, cpSl[0], cpSl)
    sl[0][0] = 11
    fmt.Printf("sl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl[0], sl)
    fmt.Printf("cpSl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &cpSl, cpSl, cpSl[0], cpSl)
    cpSl[1][0] = 22
    fmt.Printf("sl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &sl, sl, sl[0], sl)
    fmt.Printf("cpSl: 为该变量分配的地址为=%p;第一个元素切片的地址=%p;指向内存地址=%p;值=%v\n", &cpSl, cpSl, cpSl[0], cpSl)
}

D:\GOMOD\hello>go run hello.go
sl: 为该变量分配的地址为=0xc000008078;第一个元素切片的地址=0xc000060060;指向内存地址=0xc00001a098;值=[[1] [2] [3]]
cpSl: 为该变量分配的地址为=0xc000008090;第一个元素切片的地址=0xc000062050;指向内存地址=0xc00001a0e0;值=[[1] [2] [3]]
sl: 为该变量分配的地址为=0xc000008078;第一个元素切片的地址=0xc000060060;指向内存地址=0xc00001a098;值=[[11] [2] [3]]
cpSl: 为该变量分配的地址为=0xc000008090;第一个元素切片的地址=0xc000062050;指向内存地址=0xc00001a0e0;值=[[1] [2] [3]]
sl: 为该变量分配的地址为=0xc000008078;第一个元素切片的地址=0xc000060060;指向内存地址=0xc00001a098;值=[[11] [2] [3]]
cpSl: 为该变量分配的地址为=0xc000008090;第一个元素切片的地址=0xc000062050;指向内存地址=0xc00001a0e0;值=[[1] [22] [3]]

结构体

结构体拷贝：

  • 字段类型为引用类型或者指针类型，那么就会被浅拷贝
  • 字段类型为值类型，那么就是深拷贝
  • 接口虽然也是引用类型，但是属于深拷贝
/*
 * @Description:
 * @version:
 * @Author: Steven
 * @Date: 2022-10-10 23:44:53
 */
package main

import "fmt"

type goods struct {
    name  string
    sl    []int
    ptr   *int
    inter interface{}
}

func main() {
    var ga goods = goods{}
    ga.name = "辣条"
    ga.sl = make([]int, 2)
    ga.sl[0] = 20
    ga.ptr = new(int)
    ga.inter = "aaaaa"
    gb := ga
    fmt.Printf("ga[v=%+v;];gb[v=%+v]\n", ga, gb)
    gb.sl[1] = 30
    gb.name = "汉堡"
    gb.inter = "bbbbb"
    fmt.Printf("ga[v=%+v;];gb[v=%+v]\n", ga, gb)
    ga.sl[1] = 40
    ga.name = "可乐"
    ga.inter = "cccc"
    fmt.Printf("ga[v=%+v;];gb[v=%+v]\n", ga, gb)
}

运行结果:

D:\GOMOD\hello>go run hello.go
ga[v={name:辣条 sl:[20 0] ptr:0xc0000a6058 inter:aaaaa};];gb[v={name:辣条 sl:[20 0] ptr:0xc0000a6058 inter:aaaaa}]
ga[v={name:辣条 sl:[20 30] ptr:0xc0000a6058 inter:aaaaa};];gb[v={name:汉堡 sl:[20 30] ptr:0xc0000a6058 inter:bbbbb}]
ga[v={name:可乐 sl:[20 40] ptr:0xc0000a6058 inter:cccc};];gb[v={name:汉堡 sl:[20 40] ptr:0xc0000a6058 inter:bbbbb}]

狂热之人
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang常见错误之值拷贝和for循环中的单一变量详解
01-03
前言 golang(中文名：go语言)是谷歌2009发布的第二款开源编程语言。Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。。如果你想知道得更多，请移步至官网golang官网 在 Go 中函数的调用是值拷贝 copy value，而且在 for 循环中 v 的变量始终是一个变量。如果 v 是 pointer，print 这个 method 接收的是指针的拷贝，for 循环体中每次迭代 v 的 pointer value 都是不同的，所以输出不同。 在 Go 常见的错误一文中 http://devs.cloudi
golang中map/slice类型的深拷贝
仅做个人笔记
03-17 2780
转自：https://www.jianshu.com/p/b8820fd28c30 仅做个人备份，浏览请看原文 func DeepCopy(value interface{}) interface{} { if valueMap, ok := value.(map[string]interface{}); ok { newMap := make(map[string]interface{}) for k, v := range valueMap { .
Golang中的深拷贝与浅拷贝
allen的博客
05-22 1万+
一、概念 1、深拷贝（Deep Copy） 拷贝的是数据本身，创造一个样的新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值。既然内存地址不同，释放内存地址时，可分别释放。 值类型的数据，默认全部都是深复制，Array、Int、String、Struct、Float，Bool。 2、浅拷贝（Shallow Copy） 拷贝的是数据地址，只复制指向的对象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也会变化。释放内
一文带你搞懂Go语言中深拷贝与浅拷贝
最新发布
做兴趣使然的Hero
03-11 550
浅拷贝和深拷贝是Go语言中处理对象复制时的两种重要方式。它们的主要区别在于处理引用类型字段时的行为不同。理解数据结构的复制方式：在对数据进行拷贝操作时，要明确是进行浅拷贝还是深拷贝，以避免意外的数据共享或修改。避免数据共享带来的问题：当多个变量共享同一份数据时，一个变量的修改可能会影响其他变量。在需要独立操作数据时，应该使用深拷贝来复制数据。性能考虑：深拷贝通常比浅拷贝更耗时，因为需要复制整个数据结构。在处理大型数据集时，需要权衡性能和数据独立性。使用copy()函数进行切片拷贝。
利用Golang实现TCP连接的双向拷贝详解
01-01
前言 本文主要给大家介绍了关于Golang实现TCP连接的双向拷贝的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。 最简单的实现 每次来一个Server的连接，就新开一个Client的连接。用一个goroutine从server拷贝到client，再用另外一个goroutine从client拷贝到server。任何一方断开连接，双向都断开连接。 func main() { runtime.GOMAXPROCS(1) listener, err := net.Listen(tcp, 127.0.0.1:8848) if err != nil { pa
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 [
go map深度拷贝
路漫漫其修远兮
01-23 6916
func DeepCopy(value interface{}) interface{} { if valueMap, ok := value.(map[string]interface{}); ok { newMap := make(map[string]interface{}) for k, v := range valueMap { newMap[k] = DeepCopy(
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 map，slice 等地址类型变量，深拷贝
weixin_38289885的博客
05-23 582
golang map slice 等变量拷贝 由于map 变量等是是地址类型，在直接赋值的情况下，是直接将地址指针指到拷贝的地址上 输出 可看出地址是同一个 0xc0000783c0 0xc0000783c0map[name:1] map[name:1] 如果需要真正拷贝到新的地址上需要 重新每个key插入新的map 输出 0xc0000c25d0 0xc0000c2600map[name:1] map[name:1] 总结 golang 地址类型的变量。深度拷贝需要重新插入新的地址变量中 ...
go语言中的深层copy
zhuiyunzhugang的博客
04-11 153
package main import "fmt" func main(){ var a int=1 const b int=2 fmt.Println("hello world!") fmt.Println(a) fmt.Println(b) //var c int c:=1 fmt.Println(c) fmt.Printf("c type= %T\n",c) myArray:=[]int {1,2,3,4} //这里定义个一个动态数组 printArray(myArray.
go deep copy map
weixin_30614587的博客
07-31 95
func deepCopyJSON(src map[string]interface{}, dest map[string]interface{}) error { if src == nil { return errors.New("src is nil. You cannot read from a nil map") } ...
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
Golang中禁止拷贝的实现代码
09-19
主要给大家介绍了关于Golang中实现禁止拷贝的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【Go】深拷贝与浅拷贝
weixin_44211968的博客
02-27 3704
文章目录一、深浅拷贝二、深拷贝三、浅拷贝四、总结参考链接 一、深浅拷贝 在很多编程语言都有深浅拷贝的这个概念，当然golang也不例外。 在 go 语言中 值类型 赋值都是 深拷贝 ，引用类型 一般都是 浅拷贝。 其本质就是，深拷贝会拷贝数据（两变量存储地址不同，拷贝结束互不影响）。而浅拷贝只会拷贝内存的地址（即使拷贝结束，还是互相影响），所以就会出现，像 slice 那样修改底层数组的值，slice 的值也跟着改动。 二、深拷贝 b 拷贝 a 后，如果修改 a 的值，b不变，说明是值的拷贝，也就是深拷
go深拷贝和浅拷贝
小胡子
02-09 1203
go深拷贝和浅拷贝
golang map 读写锁与深度拷贝的坑
Js_123456789的博客
12-05 1253
0X01 golang中，map（字典）无法并发读写 简单来说，新建万条线程对同一个map又读又写，会报错。 为此，最好加锁，其实性能影响并不明显。 type taskCache struct{ sync.RWMutex data map[string] interface{} } 0X02 golang中，map（字典）为引用拷贝。...
golang 赋值拷贝问题
wwhhff11
05-07 8963
数组切片： func main() { m := make(map[string]interface{}, 0) l := make([]int64, 0) m["hello"] = l l = append(l,1) fmt.Println(m["hello"]) //[] } func main() { l := make([]int64, ...
golang map 锁_golang map 读写锁与深度拷贝的坑
weixin_35801828的博客
12-23 307
0X01golang中，map(字典)无法并发读写简单来说，新建万条线程对同一个map又读又写，会报错。为此，最好加锁，其实性能影响并不明显。type taskCache struct{sync.RWMutexdata map[string] interface{}}0X02golang中，map(字典)为引用拷贝。a = 字典一b = a实际上是直接将指针传给了b。于是，有一个读取，写的时候直接...
Go浅,深拷贝
weixin_42957200的博客
02-17 481
上一篇文章说了Go语言的值传递，紧接着了解一下Go的浅，深拷贝 概念： 1.浅拷贝 拷贝的是数据的地址，复制指向的对象的指针，新对象和老对象指向的内存地址是一样的，新对象修改时老对象也会被修改，释放内存地址时，同时释放 引用类型的数据，默认都是浅拷贝，slice，map，chan 2.深拷贝 拷贝的是数据本身，创造一个新的对象，新创建的对象和原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象修改时不会影响原对象值，释放内存，可分别释放 值类型的数据，默认都是深拷贝，Array,Int
go语言中map怎么进行浅拷贝和深拷贝
07-24
在Go语言中，map是一种引用类型，所赋值操作会进行浅拷贝，即只会复制指向底层数据的指针，并不会复制底层数据本身。如果需要进行深拷贝，可以通过以下方法实现： 1. 手动复制元素： - 创建一个新的空map。 - 遍历原始map的键值对，将每个键值对复制到新map中。 - 这样就创建了一个新的map，其中的键值对是原始map中键值对的副本。 示例代码： ```go originalMap := map[string]int{"a": 1, "b": 2, "c": 3} // 进行深拷贝 newMap := make(map[string]int) for key, value := range originalMap { newMap[key] = value } // 修改原始map的值 originalMap["a"] = 100 fmt.Println(originalMap) // 输出 map[a:100 b:2 c:3] fmt.Println(newMap) // 输出 map[a:1 b:2 c:3] ``` 2. 使用第三方库： - 可以使用一些第三方库来实现深拷贝，例如`github.com/mitchellh/copystructure`库提供了`copystructure.Copy()`函数，可以用于深拷贝map及其他复杂数据结构。 示例代码： ```go import ( "github.com/mitchellh/copystructure" ) originalMap := map[string]int{"a": 1, "b": 2, "c": 3} // 进行深拷贝 newMap, err := copystructure.Copy(originalMap) if err != nil { // 错误处理 } // 修改原始map的值 originalMap["a"] = 100 fmt.Println(originalMap) // 输出 map[a:100 b:2 c:3] fmt.Println(newMap) // 输出 map[a:1 b:2 c:3] ``` 无论是手动复制元素还是使用第三方库，都可以实现map的深拷贝操作。根据实际需求选择适合的方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值