比较深度嵌套的 JSON 中的子 ID 和父 ID 的关系

从现在开始，努力学习吧！本文《比较深度嵌套的 JSON 中的子 ID 和父 ID 的关系》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

这是我需要验证的 json 文档。 我必须检查 children 中的所有parent_id 是否正确。 如果所有父项和子项 id 均正确，我将返回一个“有效”字符串。

{
  "id": 10,
  "children": [
    {
      "id": 25,
      "parent_id": 10,
      "children": [
        {
          "id": 131,
          "parent_id": 25,
          "children": null
        },
        {
          "id": 33,
          "parent_id": 25,
          "children": [
            {
              "id": 138,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 139,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 140,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 160,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 34,
              "parent_id": 33,
              "children": [
                {
                  "id": 26,
                  "parent_id": 34,
                  "children": null
                },
                {
                  "id": 64,
                  "parent_id": 34,
                  "children": null
                },
                {
                  "id": 65,
                  "parent_id": 34,
                  "children": null
                }
              ]
            },
            {
              "id": 35,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 36,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 38,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 39,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 40,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 41,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 42,
              "parent_id": 33,
              "children": null
            },
            {
              "id": 148,
              "parent_id": 33,
              "children": null
            }
          ]
        },
        {
          "id": 66,
          "parent_id": 25,
          "main_id": 66,
          "children": [
            {
              "id": 144,
              "parent_id": 66,
              "children": null
            },
            {
              "id": 146,
              "parent_id": 66,
              "children": null
            },
            {
              "id": 147,
              "parent_id": 66,
              "children": null
            },
            {
              "id": 67,
              "parent_id": 66,
              "children": null
            }
          ]
        }
      ]
    }
  ]
}

我使用此代码进行迭代。但比较没有成功。我从 go 上的堆栈溢出问题之一得到了这段代码。我有点困惑从哪里开始。

func parseMap(aMap map[string]interface{}) {
    for key, val := range aMap {
        switch concreteVal := val.(type) {
        case map[string]interface{}:
            // if key == "id" {
            fmt.Println(key)
            // }
            parseMap(val.(map[string]interface{}))
        case []interface{}:
            // if key == "id" {
            fmt.Println(key)
            // }
            parseArray(val.([]interface{}))
        default:
                fmt.Println(key, ":", concreteVal)
            // if key == "parent_id" || key == "main_id" {

            // }
        }
    }
}

func parseArray(anArray []interface{}) {
    for i, val := range anArray {
        switch concreteVal := val.(type) {
        case map[string]interface{}:

            fmt.Println("Index:", i)
            parseMap(val.(map[string]interface{}))
        case []interface{}:
            fmt.Println("Index:", i)
            parseArray(val.([]interface{}))
        default:
            fmt.Println("Index", i, ":", concreteVal)
        }
    }
}

func main(w http.ResponseWriter, r *http.Request) {

    // data, err := ioutil.ReadAll(r.Body)
    m := map[string]interface{}{}

    err := json.Unmarshal([]byte(input), &m)
    if err != nil {
        panic(err)
    }
    parseMap(m)

}

我从 api 获取值，但现在我正在硬编码 json 值

解决方案

定义与数据结构匹配的类型：

type node struct {
    id       int     `json:"id"`
    parentid int     `json:"parent_id"`
    mainid   int     `json:"main_id"`
    children []*node `json:"children"`
}

编写一个递归函数来检查数据：

func check(n *node) bool {
    for _, c := range n.children {
        if c.parentid != n.id {
            return false
        }
        if !check(c) {
            return false
        }
    }
    return true
}

将 json 解组为该类型的值。检查结果。

var n node
err := json.Unmarshal(data, &n)
if err != nil {
    log.Fatal(err)
}
fmt.Println(check(&n))

Run it on the GoLang PlayGround。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《比较深度嵌套的 JSON 中的子 ID 和父 ID 的关系》文章吧，也可关注golang学习网公众号了解相关技术文章。