मुझे स्रोत ए से डेटा मिल रहा है और इसे structs के टुकड़े में संग्रहीत कर रहा है:

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
}

मैं फिर स्रोत बी से कुछ डेटा प्राप्त कर रहा हूं और इसे structs के टुकड़े में संग्रहीत कर रहा हूं:

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
}

स्रोत बी से डेटा प्राप्त करने के बाद, मैं स्रोत बी से कुछ डेटा के साथ स्रोत ए से structs के टुकड़े को अद्यतन करना चाहता हूँ।

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 में यूनिट की कीमतें अभी भी खाली हैं।

मेरी खोज से, मैं समझता हूं कि मुद्दा क्या है; जाओ मूल्य से गुजरता है और इसलिए मैं मूल स्मृति पता अपडेट नहीं कर रहा हूं और इसलिए मान नहीं बदल रहे हैं। हालाँकि, मुझे समझ नहीं आ रहा है कि मुझे इसे ठीक करने के लिए क्या बदलने की आवश्यकता है, क्योंकि मैं संख्या / तार आदि के एक सरल उदाहरण के बजाय संरचना के एक टुकड़े के साथ काम कर रहा हूँ।

मैं productPrices को कैसे अपडेट कर सकता हूं ताकि जब मैं इसे वापस कर दूं, processedProductPrices, स्ट्रक्चर्स के अपडेटेड productPrices स्लाइस के बराबर हो?

0
James 27 फरवरी 2019, 08:33

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
}
1
mkopriva 27 फरवरी 2019, 10:44