Go 复制并处理副本后，切片将被更改

我编写了这段代码用于制作切片复制，它工作正常，并且作为参数传递给函数的主切片不受影响：

主程序包
输入“fmt”
输入团队[]人
类型Person结构{
名称字符串
年龄智力
}
func main（）{
团队：=团队{
人{“哈桑”，34}，人{“卡拉姆”，32}，
}
fmt.Printf（“克隆前原件：%v\n”，团队）
团队克隆：=团队克隆（）
fmt.Printf（“克隆后原件：%v\n”，团队）
fmt.Printf（“克隆切片：%v\n”，团队\u克隆）
}
func（c*团队）克隆（）团队{
var s=制造（团队，列队（*c））
副本（s，*c）
对于索引，z:=范围s{
s[index].Name=“更改名称”
}
返回s
}

但在我的另一段代码中，即使我将

克隆

从原始切片传递给函数，原始切片也会发生变化：

type Inventory[]存货
键入清单结构{//而不是：map[string]map[string]Pairs
仓库串
项目字符串
批量
}
类型批次[]批次
类型批结构{
日期时间，时间
键串
值浮动64
}
func（c*目录）克隆（）目录{
var s=制造（存货，长度（*c））
副本（s，*c）
返回s
}
func（outs库存）BuildBatchesFrom（ins库存）（batchesBalance库存、出库库存）{
批次输出：=库存{}
对于u，in:=范围batchesBalance{
对于_，out:=范围传出{
如果out.Warehouse==in.Warehouse&&out.Item==in.Item{
批次：=批次{}
外部：
为了{
oldestBatch:=in.Batches.First（）
batchQty:=math.Min（in.Batches.First（）.Value，math.Abs（out.Batches.First（）.Value））
批次=追加（批次，批次{out.batches.First（）.Date，oldestBatch.Key，批次数量}）
out.Batches[0]。值=out.Batches.First（）。值+批次数量
in.Batches[0]。Value=oldestBatch.Value-batchQty
如果在.Batches.First（）中，则值==0{
in.Batches.PopFirst（）
}
如果out.Batches.First（）.Value==0{
out.Batches.PopFirst（）
如果len（out.Batches）==0{
打破
}否则{
继续向外
}
}否则{
继续向外
}
}
batchesOut=追加（batchesOut，库存{
仓库：出去，仓库，
项目：out.Item，
批次：批次，
})
}
}
//操作系统出口（3）
}
返回批次输出，批次平衡
} 
func main（）{
ins:=存货{
仓库：“DMM”，
物品：“手套”，
批次：批次{
标段{mustTime（time.Parse（自定义，“1/7/2020”），“Jan”，50}，
标段{mustTime（time.Parse（自定义，“2/1/2020”），“Feb”，70}，
},
}
出口：=存货{
仓库：“DMM”，
物品：“手套”，
批次：批次{
标段{mustTime（time.Parse（自定义，“1/5/2020”），“”，-10}，
标段{mustTime（time.Parse（自定义，“2/9/2020”），“”，-30}，
},
}
fmt.Printf（“\n\n[1]Ins:\n%v”，Ins）//此输出在运行完\u clone.BuildBatchesFrom（Ins\u clone）后不同
fmt.Printf（“\n\n[2]输出：\n%v”，输出）////此输出在运行完\u clone.BuildBatchesFrom（ins\u clone）后不同
ins_clone:=ins.clone（）
outs\u clone:=outs.clone（）
batchesOut，batchesBalance:=outs\u clone.BuildBatchesFrom（ins\u clone）
fmt.Printf（“\n\n[1]Ins:\n%v”，Ins）//此输出在运行\u clone.BuildBatchesFrom（Ins\u clone）之前是不同的
fmt.Printf（“\n\n[2]输出：\n%v”，输出）//此输出在运行完\u clone.BuildBatchesFrom（ins\u clone）后不同
fmt.Printf（“\n\n[4]批输出：\n%v”，批输出）
fmt.Printf（“\n\n[5]批余额：\n%v”，batchesBalance）
}

---

在上面的例子中，

ins

在运行函数后发生变化，尽管我没有将其传递到那里，

ins\u clone（）

在函数后发生变化，尽管我在函数代码的第一行克隆了它，这与

outs

和

outs\u clone（）

我得到了它，原因是我的切片包含一个子切片，

副本

对上面的切片有效，但对共享相同数据的子切片无效。我通过重新编写代码修复了它，创建了一个新切片，将数据推送到其中，然后使用它替换原始切片，如下所示：

func（i*存货）克隆自（c存货）{
存货：=新的（存货）
对于u，v:=范围c{
批次：=批次{}
对于u，b:=范围v.批次{
批次=追加（批次、批次）{
日期：b.日期，
钥匙：b.钥匙，
价值：b.价值，
})
}
*存货=追加（*存货，存货{
仓库：v.仓库，
项目：五、项目，
批次：批次，
})
}
（*i）.替换人（投资部）
}
func（i*存货）替换为（x*存货）{
*i=*x
}

这不是很简单，但我可以立即看到

Clone（）

没有复制

批处理的值。我无法理解您的代码，它有很多错误。但我认为最好使用
deepcopy.Copy
函数来克隆对象。此链接可能有用：