循环切片结构并更新值

Question

我从源A获取数据并将其存储在一系列结构中，如下所示：

type ProductPrice struct {
    Type          string
    Sku           string
    UnitPrice     string
    PriceList     string
    standardPrice string
    specialPrice  string
    specialStart  string
    specialEnd    string
    pricingUnit   string
    categoryCode  string
    isOnSpecial   bool
}

func getProductPricesFromDatabase(instance string) []ProductPrice {
    rows, err := myDBConnection.Query(// My query here)

    if err != nil {
        log.Fatal("There was an issue with the query for product price: ", err)
    }

    defer rows.Close()

    var productPrices []ProductPrice

    for rows.Next() {
        var product = ProductPrice{}
        err := rows.Scan(
            &product.Type,
            &product.Sku,
            &product.standardPrice,
            &product.specialPrice,
            &product.specialStart,
            &product.specialEnd,
            &product.pricingUnit,
            &product.PriceList,
            &product.categoryCode,
        )
        if err != nil {
            log.Fatal("product price scan error: ", err)
        }

        productPrices = append(productPrices, product)
    }

    return productPrices
}

然后我从源B获取一些数据并将其存储在一个结构片中，如下所示：

type ContractProductPrice struct {
    CustID                 string
    PriceBy                string
    AppliesTo              string
    PriceList              string
    StartDate              string
    EndDate                string
    PricingAdjustmentType  string
    PricingAdjustmentValue string
    UseLowest              string
}

func getContractProductPricesFromDatabase(instance string) []ContractProductPrice {
    rows, err := myDBConnection.Query(// My query here)

    if err != nil {
        log.Fatal("There was an issue with the query for contract product price: ", err)
    }

    defer rows.Close()

    var contractProductPrices []ContractProductPrice

    for rows.Next() {
        var product = ContractProductPrice{}
        err := rows.Scan(
            &product.CustID,
            &product.PriceBy,
            &product.AppliesTo,
            &product.PriceList,
            &product.StartDate,
            &product.EndDate,
            &product.PricingAdjustmentType,
            &product.PricingAdjustmentValue,
            &product.UseLowest,
        )
        if err != nil {
            log.Fatal("contract product price scan error: ", err)
        }
        contractProductPrices = append(contractProductPrices, product)
    }

    return contractProductPrices
}

从源B获取数据后，我想要使用源B中的一些数据更新源A的结构片。

productPrices := getProductPricesFromDatabase(instance)
contractProductPrices := getContractProductPricesFromDatabase(instance)

processedProductPrices := processProductPricesFromDatabase(productPrices, contractProductPrices)

func processProductPricesFromDatabase(productPrices []ProductPrice, contractProductPrices []ContractProductPrice) []ProductPrice {
    // Loop over contact prices and update relevant product prices
    for _, contractPrice := range contractProductPrices {
        for _, product := range productPrices {
            if contractPrice.AppliesTo == product.Sku {
                product.UnitPrice = contractPrice.PricingAdjustmentValue
            }
        }
    }

    return productPrices
}

然而，在此之后，processedProductPrices的单位价格仍然是空的。

从我的搜索中，我明白了问题所在; Go按值传递，因此我不更新原始内存地址，因此值不会更改。但是，我不明白/知道我需要改变什么来解决这个问题，因为我正在使用一些结构而不是一个简单的数字/字符串等示例。

如何更新productPrices，以便当我返回时，processedProductPrices等于更新的productPrices结构片？

Answer 1

每当你处理你知道你需要修改的值时，至少在我看来，最好使用指针。他们会让你的生活更轻松。

所以代替：

func getProductPricesFromDatabase(instance string) []ProductPrice {
    // ...
    var productPrices []ProductPrice

    for rows.Next() {
        var product = ProductPrice{}

        // ...
    }    
    return productPrices
}

我建议你重构你的代码：

func getProductPricesFromDatabase(instance string) []*ProductPrice {
    // ...
    var productPrices []*ProductPrice

    for rows.Next() {
        var product = new(ProductPrice)

        // ...
    }    
    return productPrices
}

现在对getContractProductPricesFromDatabase做同样的事情，最后将参数类型更新为processProductPricesFromDatabase函数：

func processProductPricesFromDatabase(productPrices []*ProductPrice, contractProductPrices []*ContractProductPrice) []*ProductPrice {
    // Loop over contact prices and update relevant product prices
    for _, contractPrice := range contractProductPrices {
        for _, product := range productPrices {
            if contractPrice.AppliesTo == product.Sku {
                product.UnitPrice = contractPrice.PricingAdjustmentValue
            }
        }
    }
    return productPrices
}

---

或者，如果要继续使用非指针类型，可以通过索引将切片引用的值直接修改。

func processProductPricesFromDatabase(productPrices []ProductPrice, contractProductPrices []ContractProductPrice) []ProductPrice {
    // Loop over contact prices and update relevant product prices

    for _, contractPrice := range contractProductPrices {

        for i, _ := range productPrices {
            if contractPrice.AppliesTo == productPrices[i].Sku {
                productPrices[i].UnitPrice = contractPrice.PricingAdjustmentValue
            }
        }
    }

    return productPrices
}