json - XML 到 JSON 多重嵌套

Question

我正在尝试编写代码将 XML 转换为 JSON。我要翻译的 XML 如下...

(只是一个片段)

`<version>0.1</version>
    <termsofService>http://www.wunderground.com/weather/api/d/terms.html</termsofService>
    <features>
        <feature>conditions</feature>
    </features>
  <current_observation>
        <image>
        <url>http://icons.wxug.com/graphics/wu2/logo_130x80.png</url>
        <title>Weather Underground</title>
        <link>http://www.wunderground.com</link>
        </image>
        <display_location>
        <full>Kearney, MO</full>
        <city>Kearney</city>
        <state>MO</state>
        <state_name>Missouri</state_name>`

当前代码:

`package main

import (
    "fmt"
    "net/url"
    "encoding/xml"
    "net/http"
    "log"
    "io/ioutil"
    "encoding/json"
)

type reportType struct{
    Version xml.CharData        `xml:"version"`
    TermsOfService xml.CharData `xml:"termsofService"
    `
    Features xml.CharData       `xml:"features>feature"`
    Full     xml.CharData       `xml:"current_observation>display_location>full"`
    StateName xml.CharData      `xml:"current_observation>display_location>state_name"`
    WindGust xml.CharData       `xml:"current_observation>observation_location>full"`
    Problem myErrorType     `xml:"error"`
}
type myErrorType struct{
    TypeOfError xml.CharData `xml:"type"`
    Desciption xml.CharData `xml:"description"`
}
type reportTypeJson struct{
    Version        string  `json:"version"`;
    TermsOfService string `json:"termsofService"`;
    Features    map[string]string `json:"features"`;
    Full        map[string]string `json:"display_location"`;
    WindGust map[string]string `json:"observation_location"`

}
func main() {
    fmt.Println("data is from WeatherUnderground.")
    fmt.Println("https://www.wunderground.com/")
    var state, city string
    str1 := "What is your state?"
    str2 := "What is your city?"
    fmt.Println(str1)
    fmt.Scanf("%s", &state)
    fmt.Println(str2)
    fmt.Scanf("%s", &city)
    baseURL := "http://api.wunderground.com/api/";
    apiKey := "3hunna"
    var query string

    //set up the query
    query = baseURL+apiKey +
    "/conditions/q/"+
    url.QueryEscape(state)+ "/"+
    url.QueryEscape(city)+ ".xml"
    fmt.Println("The escaped query: "+query)

    response, err := http.Get(query)
    doErr(err, "After the GET")
    var body []byte
    body, err = ioutil.ReadAll(response.Body)
    doErr(err, "After Readall")
    fmt.Println(body);
    fmt.Printf("The body: %s\n",body)

    //Unmarshalling
    var report reportType
    xml.Unmarshal(body, &report)
    fmt.Printf("The Report: %s\n", report)
    fmt.Printf("The description is [%s]\n",report.Problem.Desciption)

    //Now marshal the data out in JSON
    var data []byte
    var output reportTypeJson
    output.Version = string(report.Version);
    output.TermsOfService = string(report.TermsOfService)

    output.Features= map[string]string{"feature":string(report.Features)} // allocate a map, add the 'features' value to it and assign it to output.Features
    output.Full=map[string]string{"full":string(report.Full),"state_name":string(report.StateName)}
    output.WindGust=map[string]string{"full":string(report.WindGust)}
    data,err = json.MarshalIndent(output,"","      ")
    doErr(err, "From marshalIndent")
    fmt.Printf("JSON output nicely formatted: \n%s\n",data)


}
func doErr( err error, message string){
    if err != nil{
        log.Panicf("ERROR: %s %s \n", message, err.Error())
    }


}

如您所见，我使用 map 来映射一级嵌套，例如在 features 的情况下。但是对于两级嵌套情况，例如 xml:"current_observation>display_location>state_name"，我不知道如何创建第一级，在这种情况下 current_observations。有没有办法以某种方式创建各种 map 的 map ？非常感谢任何和所有的想法，因为我现在很困惑，感谢您的宝贵时间!

和输出:

JSON output nicely formatted: 
{
      "version": "0.1",
      "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
      "features": {
            "feature": "conditions"
      },
      "display_location": {
            "full": "Kearney, MO",
            "state_name": "Missouri"
      },
      "observation_location": {
            "full": "Stonecrest, Kearney, Missouri"
      }
}

Answer 1

您可以使用结构或 map 的 map 。我将给出两者的一些例子，从 map 的 map 开始。该类型将声明为；

CurrentObservation map[string]map[string]string `json:"current_observation"`

在这种情况下，您有一个以字符串作为键的映射，而值是另一个以字符串作为键和值的映射。结果，当您编码 json 时，您最终会得到类似的东西；

"current_observation" {
     "image": { // first level where the value is a map[string]string
          "title":"Weather Underground" // inner map, string to string
      }
}

如果说你只想打印标题，你会这样做；

fmt.Println(reportJson.CurrentObservation["image"]["title"])

由于那里的数据看起来相当静态，您也可以改用结构。在这种情况下，你会使用这样的东西；

CurrentObservation CurrentObservation `json:"current_observation"`

type CurrentObservation struct {
    Image Image `json:"image"`
}

type Image struct {
    Url string `json:"url"`
    Title string `json:"title"`
    Link string `json:"link"`
}

这两个选项产生相同的输出，尽管它们对于不同的输入可能表现不同。例如，如果接收到另一个版本的 current_observation 作为输入，例如其中有另一个嵌套项目调用它...... previous_observation 然后 map 选项将自动解码此数据以及结构选项将其排除在外的位置，因为在 Go 中不会映射到任何对象/类型。

个人而言，如果可能，我更喜欢 struct 路由，但它因情况而异。对于您的应用程序， map 可能更好，因为您不使用输入(它以 xml 形式出现)并且您只想打印它，您实际上不必处理 current_observation ，如果里面有 3 个对象，它们都会按预期输出，如果是 5 个，则相同。使用这些结构，您必须显式定义每个字段，如果您只是转换输入，这并不是真正必要的。结构的优势更多地用于稍后在您具有类型安全性的地方，尽管在这种情况下，我会说它们仍然相当等效，因为例如任何时候您想要访问图像中的某些内容，例如 CurrentObservation.Image。 Title 您必须执行检查以确保 Image 不为零，例如；

if CurrentObservation.Image != nil {
    fmt.Println(CurrentObservation.Image.Title)
}

使用 map 你基本上有相同的开销，只是你检查键的存在而不是检查其中一个内部结构是否为 nil。

编辑:使用复合文字语法初始化 map map 的示例；

   reportJson.CurrentObservation := map[string]map[string]string {
           "display_location": map[string]string {
                "full": report.Full,
                "state_name": report.StateName,
            },
    }