一篇学会Golang中深拷贝和浅拷贝

1. 什么是拷贝?

当你把 a 变量赋值给 b 变量时，其实就是把 a 变量拷贝给 b 变量

1. a := "hello" 
2.  
3. b := a 

这只是拷贝最简单的一种形式，而有些形式却表现得非常的隐蔽。比如：

• 你往一个函数中传参
• 你向通道中传入对象

这些其实在 Go编译器中都会进行拷贝的动作。

2. 什么是深浅拷贝?

知道了什么是拷贝，那我们再往深点开挖，聊聊深浅拷贝。

不过先别急，咱先了解下数据结构的两种类型：

值类型 ：String，Array，Int，Struct，Float，Bool

引用类型：Slice，Map

这两种不同的类型在拷贝的时候，在拷贝的时候效果是完全不一样的，这对于很多新手可能是一个坑。

对于值类型来说，你的每一次拷贝，Go 都会新申请一块内存空间，来存储它的值，改变其中一个变量，并不会影响另一个变量。

1. func main() { 
2.     aArr := [3]int{0,1,2} 
3.     fmt.Printf("打印 aArr: %v \n", aArr) 
4.     bArr := aArr 
5.     aArr[0] = 88 
6.     fmt.Println("将 aArr 拷贝给 bArr 后，并修改 aArr[0] = 88") 
7.     fmt.Printf("打印 aArr: %v \n", aArr) 
8.     fmt.Printf("打印 bArr: %v \n", bArr) 
9. } 

从输出结果来看，aArr 和 bArr 相互独立，互不干扰

1. 打印 aArr: [0 1 2]  
2. 将 aArr 拷贝给 bArr 后，并修改 aArr[0] = 88 
3. 打印 aArr: [88 1 2]  
4. 打印 bArr: [0 1 2]  

对于引用类型来说，你的每一次拷贝，Go 不会申请新的内存空间，而是使用它的指针，两个变量名其实都指向同一块内存空间，改变其中一个变量，会直接影响另一个变量。

1. func main() { 
2.     aslice := []int{0,1,2} 
3.     fmt.Printf("打印 aslice: %v \n", aslice) 
4.     bslice := aslice 
5.     aslice[0] = 88 
6.     fmt.Println("将 aslice 拷贝给 bslice 后，并修改 aslice[0] = 88") 
7.     fmt.Printf("打印 aslice: %v \n", aslice) 
8.     fmt.Printf("打印 bslice: %v \n", bslice) 
9. } 

从输出结果来看，aslice 的更新直接反映到了 bslice 的值。

1. 打印 aslice: [0 1 2]  
2. 将 aslice 拷贝给 bslice 后，并修改 aslice[0] = 88 
3. 打印 aslice: [88 1 2]  
4. 打印 bslice: [88 1 2]  

是不是很简单?跟着明哥一起来攻克 Go 的各个边边角角的知识吧

加油噢，我们下篇见