对切片的副本进行更改

积累知识，胜过积蓄金银！毕竟在Golang开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《对切片的副本进行更改》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

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

package main

import "fmt"

type team []person
type person struct {
    name string
    age  int
}

func main() {
    team := team{
        person{"hasan", 34}, person{"karam", 32},
    }
    fmt.printf("original before clonning: %v\n", team)
    team_cloned := team.clone()
    fmt.printf("original after clonning: %v\n", team)
    fmt.printf("clones slice: %v\n", team_cloned)
}

func (c *team) clone() team {
    var s = make(team, len(*c))
    copy(s, *c)
    for index, _ := range s {
        s[index].name = "change name"
    }
    return s
}

但是在我的其他代码中，即使我将 clone 从它传递给函数，原始切片也会发生变化：

type Inventories []Inventory
type Inventory struct { //instead of: map[string]map[string]Pairs
    Warehouse string
    Item      string
    Batches   Lots
}
type Lots []Lot
type Lot struct {
    Date  time.Time
    Key   string
    Value float64
}

func (c *Inventories) Clone() Inventories {
    var s = make(Inventories, len(*c))
    copy(s, *c)
    return s
}

func (outs Inventories) BuildBatchesFrom(ins Inventories) (batchesBalance Inventories, outgoing Inventories) {
    batchesOut := Inventories{}

    for _, in := range batchesBalance {
        for _, out := range outgoing {
            if out.Warehouse == in.Warehouse && out.Item == in.Item {
                batches := Lots{}
            OUTER:
                for {
                    oldestBatch := in.Batches.First()
                    batchQty := math.Min(in.Batches.First().Value, math.Abs(out.Batches.First().Value))

                    batches = append(batches, Lot{out.Batches.First().Date, oldestBatch.Key, batchQty})

                    out.Batches[0].Value = out.Batches.First().Value + batchQty
                    in.Batches[0].Value = oldestBatch.Value - batchQty

                    if in.Batches.First().Value == 0 {
                        in.Batches.PopFirst()
                    }
                    if out.Batches.First().Value == 0 {
                        out.Batches.PopFirst()
                        if len(out.Batches) == 0 {
                            break
                        } else {
                            continue OUTER
                        }
                    } else {
                        continue OUTER
                    }
                }
                batchesOut = append(batchesOut, Inventory{
                    Warehouse: out.Warehouse,
                    Item:      out.Item,
                    Batches:   batches,
                })
            }
        }
        //os.Exit(3)
    }
    return batchesOut, batchesBalance
} 

func main() {
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("\n\n[1] Ins: \n%v", ins)     // This output is different after running outs_clone.BuildBatchesFrom(ins_clone)
    fmt.Printf("\n\n[2] Outs: \n%v", outs)   //  // This output is different after running outs_clone.BuildBatchesFrom(ins_clone)

        ins_clone := ins.Clone()
    outs_clone := outs.Clone()

    batchesOut, batchesBalance := outs_clone.BuildBatchesFrom(ins_clone)

    fmt.Printf("\n\n[1] Ins: \n%v", ins)    // This output is different before running outs_clone.BuildBatchesFrom(ins_clone)
    fmt.Printf("\n\n[2] Outs: \n%v", outs)   // This output is different after running outs_clone.BuildBatchesFrom(ins_clone)

    fmt.Printf("\n\n[4] Batches outs: \n%v", batchesOut)
    fmt.Printf("\n\n[5] Batches Balances: \n%v", batchesBalance)
}

在上面， ins 在运行函数后正在更改，尽管我没有将其传递到那里，并且 ins_clone() 在函数之后正在更改，尽管我在函数代码的第一行中克隆它，相同对于 outs 和 outs_clone()

解决方案

我明白了，原因是我的切片包含一个 sub slice 所以 copy 适用于顶部切片，但不适用于共享相同数据的子切片，我通过重写代码来修复它创建一个新切片，将数据推送到其中，然后用它替换原始切片，如下所示：

func (i *Inventories) CloneFrom(c Inventories) {
    inv := new(Inventories)
    for _, v := range c {
        batches := Lots{}
        for _, b := range v.Batches {
            batches = append(batches, Lot{
                Date:  b.Date,
                Key:   b.Key,
                Value: b.Value,
            })
        }

        *inv = append(*inv, Inventory{
            Warehouse: v.Warehouse,
            Item:      v.Item,
            Batches:   batches,
        })
    }
    (*i).ReplaceBy(inv)
}

func (i *Inventories) ReplaceBy(x *Inventories) {
    *i = *x
}

理论要掌握，实操不能落！以上关于《对切片的副本进行更改》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！