如何在不同结构中复制重复的子结构？

大家好，今天本人给大家带来文章《如何在不同结构中复制重复的子结构？》，文中内容主要涉及到，如果你对Golang方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

我有一个结构，我已将一个大型 xml 文档解组到其中。 我希望从结构中提取某些元素并将它们复制到新的结构中。然而，其中许多是在另一个结构中重复的结构

考虑以下示例（整个结构的一小部分）：

1）传入数据的格式

type productheader struct {
    products struct {
        productid string `xml:"productid"`
        product   struct {
            pricebands struct {
                priceband []struct {
                    unitprice string `xml:"unitprice"`
                    lowerqty  string `xml:"lowerqty"`
                    upperqty  string `xml:"upperqty"`
                } `xml:"priceband"`
            } `xml:"pricebands"`
        } `xml:"product"`
    } `xml:"products"`
}

2）我希望输出的数据格式

type productout struct {
    productid string `json:"productid"`

    pricebands struct {
        priceband []struct {
            unitprice    float32 `json:"unitprice"`
            lowerqty float32 `json:"lowerqty"`
            upperqty float32 `json:"upperqty"`
        } `json:"priceband"`
    } `json:"pricebands"`
}

xml 输入示例

<?xml version="1.0" encoding="utf-8"?>
<productheader>
    <products xmlns="">
        <productid>123xyz</productid>
         <product>
            <pricebands>
                <priceband>
                    <unitprice>25.75</unitprice>
                    <lowerqty>0.00</lowerqty>
                    <upperqty>100.00</upperqty>
                </priceband>
                <priceband>
                    <unitprice>23.99</unitprice>
                    <lowerqty>100.01</lowerqty>
                    <upperqty>1000.00</upperqty>
                </priceband>
                <priceband>
                    <unitprice>21.00</unitprice>
                    <lowerqty>1000.01</lowerqty>
                    <upperqty>null</upperqty>
                </priceband>
            </pricebands>
        </product>
    </products>
</productheader>

目标输出示例

{
    "productid" : "123xyz",
    "pricebands" : [ 
        {
            "unitprice" : 25.75,
            "lowerqty" : 0.00,
            "upperqty" : 100.00
        },
        {
            "unitprice" : 23.99,
            "lowerqty" : 100.01,
            "upperqty" : 1000.00
        },
        {
            "unitprice" : 21.00,
            "lowerqty" : 1000.01,
            "upperqty" : null
        }
    ]
}

如您所见，产品可能有多个价格范围。我最初以为我可以简单地以以下形式分配整个 pricebands 元素：

var p1 productheader
var p2 productout

    p2.pricebands = p1.products.product.pricebands

但这会产生编译器错误，这是有道理的，因为 priceband 实例的数量在编译时是可变且未知的。

然而，这也是有道理的：

p2.PriceBands.PriceBand = p1.ProductHeader.PriceBands.PriceBand

这让我认为我需要以某种方式迭代 pricebands 结构。

在 python 中，我可以在 productbands 中执行类似 for productband 的操作，但该语法在 go 中似乎不可用。

go 中迭代结构 1) 并将价格带移动到结构 2) 的具体实例中的正确方法是什么，我随后可以将其解组为 json，如上面的示例输出所示。

解决方案

正确的做法是：

• 将输入 xml 流解组到 productin 变量 in
• 使用任何必要的转换（包括 for ... range 列表循环）将所需数据从 in 复制到 productout 变量 out。

如果 productout 的整个子树与 productin 的子树的结构完全匹配，那么您可以分配（例如 out.pricebands = in.productheader.pricebands），而无需显式循环。警告：in 和 out 对象现在通过引用（通过切片）共享一些内存，并且修改 in 可能会修改 out。如果不再使用 in 也没关系。

无论如何，我根本不建议对重复字段使用反射，它们应该可以很好地转换为切片。

尝试这个：

package main

import (
    "encoding/json"
    "encoding/xml"
    "fmt"
    "io/ioutil"
    "os"
)

type ProductHeaders struct {
    XMLName  xml.Name   `xml:"ProductHeader"`
    Products []Products `xml:"Products"`
}

type Products struct {
    XMLName xml.Name `xml:"Products"`
    Id      string   `xml:"Id"`
    Product Product  `xml:"Product"`
}
type Product struct {
    XMLName    xml.Name   `xml:"Product"`
    PriceBands PriceBands `xml:"PriceBands"`
}
type PriceBand struct {
    XMLName   xml.Name `xml:"PriceBand" json:"-"`
    UnitPrice string   `xml:"UnitPrice" json:"unitPrice"`
    LowerQty  string   `xml:"LowerQty" json:"lowerQty"`
    UpperQty  string   `xml:"UpperQty" json:"upperQty"`
}
type PriceBands struct {
    XMLName   xml.Name    `xml:"PriceBands"`
    PriceBand []PriceBand `xml:"PriceBand"`
}

func main() {

    xmlFile, err := os.Open("/home/prakash/Desktop/demo.xml")
    if err != nil {
        fmt.Println(err)
    }
    defer xmlFile.Close()
    byteValue, _ := ioutil.ReadAll(xmlFile)
    var hdrs ProductHeaders

    out := make(map[string]interface{}) // USING MAP OF INTERFACE
    err = xml.Unmarshal(byteValue, &hdrs)
    if err != nil {
        fmt.Println(err)
    }
    for _, val := range hdrs.Products {
        out["productId"] = val.Id
        data, err := json.Marshal(val.Product.PriceBands.PriceBand)
        // MODIFY THE LOGIC HERE AS PER NEED
        if err != nil {
            fmt.Println(err)
        }
        out["priceBands"] = string(data)
    }
    fmt.Println(out)
    //map[priceBands:[{"unitPrice":"25.75","lowerQty":"0.00","upperQty":"100.00"},{"unitPrice":"23.99","lowerQty":"100.01","upperQty":"1000.00"},{"unitPrice":"21.00","lowerQty":"1000.01","upperQty":"NULL"}] productId:123XYZ]

}

这是输出：

好了，本文到此结束，带大家了解了《如何在不同结构中复制重复的子结构？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！