Question

我正在尝试加载一个具有x个JSON数组的相当大的JSON文件。我遇到的问题是以下数据中的每个节点都有一个唯一的名称，因此我不确定如何构建存储它们的结构。

以下是JSON文件中的数据片段（此文件可以包含仅两个以下的更多节点）

       {
            "timestamp": 1533397325,
            "total_nodes": 9522,
            "latest_height": 535196,
            "nodes": {
                "220.75.229.130:3927": [
                    70015,
                    "/Satoshi:0.13.2/",
                    1530858117,
                    13,
                    165277,
                    "220.75.229.130",
                    "Seoul",
                    "KR",
                    37.5985,
                    126.9783,
                    "Asia/Seoul",
                    "AS4766",
                    "Korea Telecom"
                ],
                "192.162.102.68:8333": [
                    70015,
                    "/Satoshi:0.15.1/",
                    1533061934,
                    13,
                    535196,
                    "192.162.102.68",
                    null,
                    "RU",
                    55.7386,
                    37.6068,
                    null,
                    "AS50113",
                    "MediaServicePlus LLC"
                ]        
          }
}

到目前为止，这是我的代码，以及Go中的JSON对象：

type MyJsonName struct {
    LatestHeight int `json:"latest_height"`
    Timestamp    int `json:"timestamp"`
    TotalNodes   int `json:"total_nodes"`
    Nodes        struct {
        Data string
    } `json:"nodes"`
}

func main() {
    jsonFile, err := os.Open("someFile")
    if err != nil {
        fmt.Println(err)
    }
    byteValue, _ := ioutil.ReadAll(jsonFile)
    var MyJSONANE MyJsonName
    err = json.Unmarshal(byteValue, &MyJSONANE)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(MyJSONANE)
}

这段代码很好用，我的问题是节点中的数据从未填充过JSON数组及其内容。

这是输出：{535196 1533397325 9522 {}}

任何帮助我调整结构以读取JSON数组的帮助将不胜感激。我只想强调节点中JSON数组的名称是唯一的，并且可以有total_nodes个数量。

Answer 1

选择map[string]interface{}存储节点数据。对于带有动态键的未知json数据，最好使用接口，这将帮助您存储任何类型的数据。

package main

import (
    "fmt"
    "encoding/json"
)

type MyJsonName struct {
    LatestHeight int `json:"latest_height"`
    Timestamp    int `json:"timestamp"`
    TotalNodes   int `json:"total_nodes"`
    Nodes  map[string]interface{}
}

var byteValue string = `{
  "timestamp": 1533397325,
  "total_nodes": 9522,
  "latest_height": 535196,
  "nodes": {
    "220.75.229.130:3927": [
      70015,
      "/Satoshi:0.13.2/",
      1530858117,
      13,
      165277,
      "220.75.229.130",
      "Seoul",
      "KR",
      37.5985,
      126.9783,
      "Asia/Seoul",
      "AS4766",
      "Korea Telecom"
    ],
    "192.162.102.68:8333": [
      70015,
      "/Satoshi:0.15.1/",
      1533061934,
      13,
      535196,
      "192.162.102.68",
      null,
      "RU",
      55.7386,
      37.6068,
      null,
      "AS50113",
      "MediaServicePlus LLC"
    ]
  }
}`

func main() {
    var MyJSONANE MyJsonName
    err := json.Unmarshal([]byte(byteValue), &MyJSONANE)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%+v",MyJSONANE)
}

在Go playground上工作的代码

要从interface{}获取基础值，您需要为每种类型声明类型。您可以通过switch递归地从接口获取值。

func fetchValue(value interface{}) {
    switch value.(type) {
    case string:
        fmt.Printf("%v is an string \n ", value.(string))
    case bool:
        fmt.Printf("%v is bool \n ", value.(bool))
    case float64:
        fmt.Printf("%v is float64 \n ", value.(float64))
    case []interface{}:
        fmt.Printf("%v is a slice of interface \n ", value)
        for _, v := range value.([]interface{}) {
            fetchValue(v)
        }
    case map[string]interface{}:
        fmt.Printf("%v is a map \n ", value)
        for _, v := range value.(map[string]interface{}) {
            fetchValue(v)
        }
    default:
        fmt.Printf("%v is unknown \n ", value)
    }
}

构建golang结构以存储来自解析的JSON文件的数据

1 个答案: