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

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

下面是JSON文件中的数据片段（这个文件可以有更多的节点，而下面只有两个节点）

到目前为止，这是我的代码和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数组的名称是唯一的，可以有

总节点数

个。

使用

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)
}

工作守则

要从

接口{}

获取基础值，需要对每个类型进行类型断言。您可以使用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)
    }
}

---

这就是我一直在寻找的解决方案，我已经花了好几个小时试图解决这个问题。非常感谢。

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)
    }
}