如何动态填充结构体？

小伙伴们对Golang编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《如何动态填充结构体？》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

我想动态填充我的内部结构，以进行原子插入。我是新手，所以指针和引用它们是我仍在学习的东西。我不明白为什么每个循环都会将相同的字段放入两次。我尝试删除“&”，然后出现无法使用类型作为*类型错误，我检查以确保我的循环命中了 tradearray 中的每个对象，确实如此。看起来它正在用它循环的最后一个对象覆盖它之前的对象。我该如何解决这个问题？

func createtrade(w http.responsewriter, r *http.request) {
        w.header().set("content-type", "application/json")

        var tradearray []trade
    
    
        if err := json.newdecoder(r.body).decode(&tradearray); err != nil {
            e := error{message: "bad request - improper types passed"}
            w.writeheader(http.statusbadrequest)
            _ = json.newencoder(w).encode(e)
            return
        }
    
    
        for _, trade := range tradearray {
            internal := internaltrade{
                id: strconv.itoa(rand.intn(1000000)),
                trade: &trade,
            }
            submit := tradesubmitted{
                tradeid:       internal.id,
                clienttradeid: trade.clienttradeid ,
            }
            submitarray = append(submitarray, submit)
            trades = append(trades, internal)
        }
    
    
        if err := json.newencoder(w).encode(submitarray); err != nil {
            e := error{message:"internal server error"}
            w.writeheader(http.statusinternalservererror)
            _ = json.newencoder(w).encode(e)
            return
        }
    }

编辑：我能够通过创建一个新变量来保存交易并在结构创建中引用该变量来解决我的问题。我不确定这与我上面所做的仅引用“交易”有何不同，如果有人可以解释我将不胜感激。

for _, trade := range tradeArray {
    p := trade
    internal := InternalTrade{
        Id: strconv.Itoa(rand.Intn(1000000)),
        Trade: &p,
    }
    submit := TradeSubmitted{
        TradeId:       internal.Id,
        ClientTradeId: trade.ClientTradeId ,
    }
    submitArray = append(submitArray, submit)
    trades = append(trades, internal)
}

解决方案

让我们看看这些部分：

var tradearray []trade

    // code that fills in `tradearray` -- correct, and omitted here

    for _, trade := range tradearray {
        internal := internaltrade{
            id: strconv.itoa(rand.intn(1000000)),
            trade: &trade,
        }
        submit := tradesubmitted{
            tradeid:       internal.id,
            clienttradeid: trade.clienttradeid ,
        }
        submitarray = append(submitarray, submit)
        trades = append(trades, internal)
    }

正如您所见，这个 for 循环不按照您想要的方式工作。这是它的一个变体，有点相似，只是变量 trade 的范围超出了 for 循环：

var trade trade
    for i := range tradearray {
        trade = tradearray[i]
        internal := internaltrade{
            id: strconv.itoa(rand.intn(1000000)),
            trade: &trade,
        }
        // do correct stuff with `internal`
    }

请注意，每个 internal 对象都指向一个单个共享 trade 变量，其值在每次循环过程中都会被覆盖。结果是它们都指向循环中最后行程中的那个。

您的修复本身没问题：每次循环，您都会创建一个新（不同的）p变量，并使用&p，以便每个internal.trade都有一个指向不同副本的不同指针。您也可以在循环内执行 trade := trade 来创建一个新的唯一 trade 变量。但是，在这种特定情况下，以这种方式重写循环可能最有意义：

for i := range tradearray {
        internal := internaltrade{
            id: strconv.itoa(rand.intn(1000000)),
            trade: &tradearray[i],
        }
        // do correct stuff with `internal`
    }

也就是说，您已经拥有 len(tradearray) 不同 trade 对象：切片标头 tradearray 使您可以访问存储在底层数组中的每个 tradearray[i] 实例。您可以直接指向这些内容。

这种方法有多种优点和缺点。最大的优点是您根本不需要重新复制每笔交易：您只需使用切片头覆盖的数组中的那些，该数组是在 json decode 函数内的某处分配的。最大的缺点是，只要您保留指向其元素的任何指针，该底层数组就无法被垃圾收集。该缺点可能根本没有任何成本，具体取决于剩余代码的结构，但如果它是一个缺点，请考虑将 tradearray 声明为：

var tradeArray []*Trade

这样 json decode 函数会单独分配每个集合，并且您可以一次指向它们一个，而无需强制保留整个集合。

本篇关于《如何动态填充结构体？》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注编程网公众号！