当前位置：首页 > 文章列表 > Golang > Go教程 > Golang值类型拷贝：浅拷贝与深拷贝区别

Golang值类型拷贝：浅拷贝与深拷贝区别

2026-01-29 15:55:55 0浏览收藏

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《Golang值类型拷贝详解：浅拷贝与深拷贝区别》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下，希望所有认真读完的童鞋们，都有实质性的提高。

Go无内置深拷贝机制，其拷贝行为取决于类型：纯值类型赋值即深拷贝，指针/切片/map等句柄类型赋值为浅拷贝；需手动逐字段处理或用copy()、序列化等方式实现可控拷贝。

如何在Golang中实现值类型拷贝_理解浅拷贝与深拷贝

Go 里没有“深拷贝”这个内置概念

Go 语言本身不提供 deep copy 或 shallow copy 的语言级关键字或运行时函数。所谓“浅拷贝”和“深拷贝”，只是开发者对值传递行为的归纳描述——它完全取决于你拷贝的是什么类型、怎么拷贝的。

根本原因在于：Go 只有值传递（包括指针值的传递），没有引用传递。所以关键不是“要不要深”，而是“你传的是什么，它指向了什么”。

int、string、struct{}（不含指针/切片/map/chan）这类纯值类型，赋值即复制全部内容，天然“深”
[]int、map[string]int、*T、chan int 这些类型，变量本身是轻量句柄（header），赋值只复制句柄，底层数据仍共享——这就是常说的“浅”
例如 slice 赋值后两个变量共用同一底层数组，改一个会影响另一个

用 `copy()` 手动实现 slice 的值拷贝

对 []T 类型，最常用、最可控的值拷贝方式是 copy() 函数，它只复制元素值，不共享底层数组。

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // dst 是独立副本
dst[0] = 999
// src 仍是 [1 2 3]，未受影响

copy(dst, src) 要求 dst 已分配足够空间；若长度不足，只复制 min(len(dst), len(src)) 个元素
不能用 dst := src 替代——那只是 header 拷贝，后续修改会相互干扰
对于嵌套 slice（如 [][]int），copy() 只拷贝外层 slice header 和元素（即内层数组指针），不递归拷贝内层数组——仍是浅的

结构体含指针/切片时，如何安全拷贝

当 struct 包含 []T、map[K]V、*T 等字段时，直接赋值只是浅拷贝。要得到完全独立副本，需手动逐字段深拷贝。

type Config struct {
    Name string
    Tags []string
    Meta map[string]interface{}
    Owner *User
}

c1 := Config{
    Name: "app",
    Tags: []string{"dev", "go"},
    Meta: map[string]interface{}{"v": 1},
    Owner: &User{Name: "Alice"},
}
c2 := c1 // 浅拷贝：Tags/Meta/Owner 全部共享

// 正确做法：手动构造新值
c2 = Config{
    Name: c1.Name,
    Tags: append([]string(nil), c1.Tags...), // 安全拷贝 slice
    Meta: func(m map[string]interface{}) map[string]interface{} {
        r := make(map[string]interface{})
        for k, v := range m {
            r[k] = v // 注意：这里没递归拷贝 interface{} 值，仅适用于基本类型
        }
        return r
    }(c1.Meta),
    Owner: &User{Name: c1.Owner.Name}, // 指针解引用后新建
}

append([]T(nil), s...) 是拷贝 []T 的惯用写法，比 make+copy 更简洁
map 拷贝必须遍历，且如果 value 是指针或复杂结构，还需进一步处理
没有银弹：一旦结构体嵌套层级变深或含 interface{}，手动拷贝极易遗漏，此时应考虑序列化方案

用 `encoding/gob` 或 `json` 实现通用深拷贝（慎用）

对任意可序列化的值，可通过编解码绕过共享问题，实现“逻辑深拷贝”。但这是模拟，不是语言原生能力，有明显代价。

import "encoding/gob"
import "bytes"

func deepCopy(v interface{}) interface{} {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)
    dec := gob.NewDecoder(&buf)
    enc.Encode(v)
    var dst interface{}
    dec.Decode(&dst)
    return dst
}