Go语言Range循环中数组浅拷贝问题及深拷贝实现问询

你遇到的现象本质是：Go的range遍历切片时，每次迭代的临时变量是原元素的浅拷贝。因为Recording结构体中的Videos是切片（引用类型），浅拷贝仅复制了切片的引用信息（指向底层数组的指针、长度、容量），而非底层数组本身，所以修改临时变量的Videos会直接影响原切片元素的底层数组，导致意外的修改。

以下是几种在range循环中实现深拷贝的可行方法：

方法1：手动逐字段拷贝（推荐简单场景） #

针对结构体的每个字段，手动复制值；对于引用类型（如切片），创建新的实例并复制底层元素，确保完全独立于原数据。

示例：生成不影响原切片的深拷贝集合 #

package main

import "fmt"

func main() {
    type Recording struct {
        Heartbeat string   `json:"heartbeat"`
        Videos    []string `json:"videos,omitempty"`
    }

    recordings := []Recording{{Heartbeat: "Blue", Videos: []string{"Foo"}}}
    // 创建用于存储深拷贝结果的切片
    deepCopiedRecordings := make([]Recording, len(recordings))

    for i, orig := range recordings {
        // 深拷贝Videos切片：创建新切片并复制元素
        copiedVideos := make([]string, len(orig.Videos))
        copy(copiedVideos, orig.Videos)
        // 组装新的Recording实例
        deepCopiedRecordings[i] = Recording{
            Heartbeat: orig.Heartbeat,
            Videos:    copiedVideos,
        }
        // 修改深拷贝后的元素，不会影响原切片
        deepCopiedRecordings[i].Videos[0] = "Bar"
    }

    fmt.Println("原切片:", recordings)          // 输出 [{Blue [Foo]}]
    fmt.Println("深拷贝切片:", deepCopiedRecordings) // 输出 [{Blue [Bar]}]
}

如果需要修改原切片的同时避免浅拷贝问题，也可以通过索引直接操作原元素，并先深拷贝后再修改：

for i := range recordings {
    // 先深拷贝原元素的Videos
    copiedVideos := make([]string, len(recordings[i].Videos))
    copy(copiedVideos, recordings[i].Videos)
    // 修改拷贝后的切片，再替换回原切片
    copiedVideos[0] = "Bar"
    recordings[i].Videos = copiedVideos
}

方法2：反射实现通用深拷贝（适合复杂结构体） #

如果结构体字段多、有嵌套引用类型（如嵌套切片、指针、map），可以用反射实现一个通用的深拷贝函数，避免重复的手动拷贝代码。

示例：通用深拷贝函数及使用 #

package main

import (
    "fmt"
    "reflect"
)

func deepCopy(dst, src interface{}) error {
    // 要求目标和源都为指针类型
    if reflect.TypeOf(dst).Kind() != reflect.Ptr || reflect.TypeOf(src).Kind() != reflect.Ptr {
        return fmt.Errorf("dst and src must both be pointers")
    }
    srcVal := reflect.ValueOf(src).Elem()
    dstVal := reflect.ValueOf(dst).Elem()
    // 要求源和目标类型一致
    if srcVal.Type() != dstVal.Type() {
        return fmt.Errorf("src and dst must be the same type")
    }
    copyValue(dstVal, srcVal)
    return nil
}

func copyValue(dst, src reflect.Value) {
    switch src.Kind() {
    case reflect.Struct:
        // 遍历结构体字段递归拷贝
        for i := 0; i < src.NumField(); i++ {
            copyValue(dst.Field(i), src.Field(i))
        }
    case reflect.Slice:
        // 创建新切片并复制元素
        newSlice := reflect.MakeSlice(src.Type(), src.Len(), src.Cap())
        reflect.Copy(newSlice, src)
        dst.Set(newSlice)
    case reflect.Ptr:
        // 指针类型：创建新指针并拷贝指向的值
        if src.IsNil() {
            dst.Set(reflect.Zero(src.Type()))
            return
        }
        newPtr := reflect.New(src.Type().Elem())
        copyValue(newPtr.Elem(), src.Elem())
        dst.Set(newPtr)
    case reflect.Map:
        // Map类型：创建新Map并复制键值对
        if src.IsNil() {
            dst.Set(reflect.Zero(src.Type()))
            return
        }
        newMap := reflect.MakeMap(src.Type())
        for _, key := range src.MapKeys() {
            val := src.MapIndex(key)
            copiedVal := reflect.New(val.Type()).Elem()
            copyValue(copiedVal, val)
            newMap.SetMapIndex(key, copiedVal)
        }
        dst.Set(newMap)
    default:
        // 基础类型直接赋值
        dst.Set(src)
    }
}

func main() {
    type Recording struct {
        Heartbeat string   `json:"heartbeat"`
        Videos    []string `json:"videos,omitempty"`
    }

    recordings := []Recording{{Heartbeat: "Blue", Videos: []string{"Foo"}}}
    deepCopied := make([]Recording, len(recordings))

    for i := range recordings {
        if err := deepCopy(&deepCopied[i], &recordings[i]); err != nil {
            panic(err)
        }
        deepCopied[i].Videos[0] = "Bar"
    }

    fmt.Println("原切片:", recordings)    // 输出 [{Blue [Foo]}]
    fmt.Println("深拷贝切片:", deepCopied) // 输出 [{Blue [Bar]}]
}

注意事项 #

1. 手动拷贝性能更高，逻辑清晰，适合字段较少的简单结构体；
2. 反射实现的通用深拷贝需要覆盖所有需要处理的引用类型（切片、指针、map等），否则仍可能存在浅拷贝风险；
3. 如果结构体包含自定义类型，需要扩展copyValue函数以支持该类型的深拷贝。

内容的提问来源于stack exchange，提问作者Adeel Abbas