Question

我有一个看起来像这样的json文件

{
  "links": {
    "uniqueurl_1": {
      "a": {
        "b": [
          "stuff"
        ],
        "I": {
          "want": {
            "to": "morestuff",
            "go": {
              "in": {
                "here": {
                  "and": "array",
                  "itis": {
                    "very": "string",
                    "deep": "stringIwant"
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

我想获取uniqueurl_1（每个链接总是不同的），并且我还想获取“深度”字段的值（“ stringIwant”）

我知道它的嵌套不是太深，您可以在Golang中创建一堆结构，但是当深度太深时，它仍然是唯一/最好的方法吗？

Answer 1

JSON中的

缺少大括号。试试这种方式：

{
  "links": {
    "uniqueurl_1": {
      "a": {
        "b": [
          "stuff"
        ],
        "I": {
          "want": {
            "to": "morestuff",
            "go": {
              "in": {
                "here": {
                  "and": "array",
                  "itis": {
                    "very": "string",
                    "deep": "stringIwant"
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

并使用以下代码访问您的数据：

package main

import "encoding/json"

func UnmarshalNotSoDeep(data []byte) (NotSoDeep, error) {
    var r NotSoDeep
    err := json.Unmarshal(data, &r)
    return r, err
}

func (r *NotSoDeep) Marshal() ([]byte, error) {
    return json.Marshal(r)
}

type NotSoDeep struct {
    Links Links `json:"links"`
}

type Links struct {
    Uniqueurl1 Uniqueurl1 `json:"uniqueurl_1"`
}

type Uniqueurl1 struct {
    A A `json:"a"`
}

type A struct {
    B []string `json:"b"`
    I I        `json:"I"`
}

type I struct {
    Want Want `json:"want"`
}

type Want struct {
    To string `json:"to"`
    Go Go     `json:"go"`
}

type Go struct {
    In In `json:"in"`
}

type In struct {
    Here Here `json:"here"`
}

type Here struct {
    And  string `json:"and"` 
    Itis Itis   `json:"itis"`
}

type Itis struct {
    Very string `json:"very"`
    Deep string `json:"deep"`
}

Answer 2

在这种情况下，您可以使用gojsonq - A simple Go package to Query over JSON Data库。这是full list of available queries。

因此，如果要获取值（stringIwant，则可以选择方法From或方法Find。

以下示例：

package main

import (
    "fmt"

    "github.com/thedevsaddam/gojsonq"
)

const json = `{
  "links": {
    "uniqueurl_1": {
      "a": {
        "b": [
          "stuff"
        ],
        "I": {
          "want": {
            "to": "morestuff",
            "go": {
              "in": {
                "here": {
                  "and": "array",
                  "itis": {
                    "very": "string",
                    "deep": "stringIwant"
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}`

func main() {
    key := "uniqueurl_1"
    query := "links." + key + ".a.I.want.go.in.here.itis.deep"
    fmt.Println(gojsonq.New().JSONString(json).From(query).Get())
    fmt.Println(gojsonq.New().JSONString(json).Find(query).(string))
}

输出：

stringIwant

stringIwant

如何在Golang中获取JSON唯一字段的名称和深度嵌套的子字段的值？

2 个答案: