Golang中切片在复制后操作副本时原切片被修改的问题

这个问题是因为Go语言中切片和结构体的浅拷贝特性导致的。在你的代码中，Clone()方法只复制了切片本身，但没有复制切片中的元素。

问题分析

1. 第一个示例能正常工作的原因：

func (c *Team) Clone() Team {
    var s = make(Team, len(*c))
    copy(s, *c)  // 这里复制的是Person结构体，结构体是值类型
    for index, _ := range s {
        s[index].Name = "change name"  // 修改的是副本
    }
    return s
}

1. 第二个示例出问题的原因：

func (c *Inventories) Clone() Inventories {
    var s = make(Inventories, len(*c))
    copy(s, *c)  // 这里只复制了Inventory结构体，但Inventory包含Lots切片
    return s
}

根本原因

Inventory结构体中的Batches字段是Lots类型（[]Lot切片）。当复制Inventory结构体时，Batches字段被浅拷贝，这意味着新旧结构体共享同一个底层数组。

解决方案

你需要实现深拷贝。以下是修复后的代码：

// 为Lot实现Clone方法
func (l Lot) Clone() Lot {
    return Lot{
        Date:  l.Date,
        Key:   l.Key,
        Value: l.Value,
    }
}

// 为Lots实现Clone方法
func (l Lots) Clone() Lots {
    s := make(Lots, len(l))
    for i, lot := range l {
        s[i] = lot.Clone()
    }
    return s
}

// 为Inventory实现Clone方法
func (i Inventory) Clone() Inventory {
    return Inventory{
        Warehouse: i.Warehouse,
        Item:      i.Item,
        Batches:   i.Batches.Clone(),  // 关键：深拷贝Batches
    }
}

// 为Inventories实现Clone方法
func (c Inventories) Clone() Inventories {
    s := make(Inventories, len(c))
    for i, inv := range c {
        s[i] = inv.Clone()  // 深拷贝每个Inventory
    }
    return s
}

完整示例

package main

import (
    "fmt"
    "time"
)

type Inventories []Inventory

type Inventory struct {
    Warehouse string
    Item      string
    Batches   Lots
}

type Lots []Lot

type Lot struct {
    Date  time.Time
    Key   string
    Value float64
}

// Lot的深拷贝
func (l Lot) Clone() Lot {
    return Lot{
        Date:  l.Date,
        Key:   l.Key,
        Value: l.Value,
    }
}

// Lots的深拷贝
func (l Lots) Clone() Lots {
    s := make(Lots, len(l))
    for i, lot := range l {
        s[i] = lot.Clone()
    }
    return s
}

// Inventory的深拷贝
func (i Inventory) Clone() Inventory {
    return Inventory{
        Warehouse: i.Warehouse,
        Item:      i.Item,
        Batches:   i.Batches.Clone(),
    }
}

// Inventories的深拷贝
func (c Inventories) Clone() Inventories {
    s := make(Inventories, len(c))
    for i, inv := range c {
        s[i] = inv.Clone()
    }
    return s
}

func main() {
    custom := "1/2/2006"
    
    ins := Inventory{
        Warehouse: "DMM",
        Item:      "Gloves",
        Batches: Lots{
            Lot{mustTime(time.Parse(custom, "1/7/2020")), "Jan", 50},
            Lot{mustTime(time.Parse(custom, "2/1/2020")), "Feb", 70},
        },
    }

    outs := Inventory{
        Warehouse: "DMM",
        Item:      "Gloves",
        Batches: Lots{
            Lot{mustTime(time.Parse(custom, "1/5/2020")), "", -10},
            Lot{mustTime(time.Parse(custom, "2/9/2020")), "", -30},
        },
    }

    fmt.Printf("原始ins: %+v\n", ins)
    fmt.Printf("原始outs: %+v\n", outs)
    
    // 创建Inventories切片
    inventories := Inventories{ins, outs}
    
    // 深拷贝
    cloned := inventories.Clone()
    
    // 修改克隆后的数据
    cloned[0].Batches[0].Value = 100
    
    fmt.Printf("\n修改后原始ins: %+v\n", inventories[0])  // Value仍然是50
    fmt.Printf("修改后克隆ins: %+v\n", cloned[0])         // Value变为100
}

func mustTime(t time.Time, err error) time.Time {
    if err != nil {
        panic(err)
    }
    return t
}

关键点

1. 值类型 vs 引用类型：

   • 结构体是值类型，复制时会创建新实例
   • 切片是引用类型，复制时只复制切片头，底层数组共享

2. 深拷贝原则：

   • 对于包含引用类型字段的结构体，需要递归实现深拷贝
   • 每个包含切片或指针的层级都需要实现自己的Clone方法

3. 性能考虑：

   • 深拷贝比浅拷贝消耗更多内存和时间
   • 根据实际需求选择适当的拷贝策略