生成 JSON 对象的嵌套哈希值

“纵有疾风来，人生不言弃”，这句话送给正在学习Golang的朋友们，也希望在阅读本文《生成 JSON 对象的嵌套哈希值》后，能够真的帮助到大家。我也会在后续的文章中，陆续更新Golang相关的技术文章，有好的建议欢迎大家在评论留言，非常感谢！

我有两个具有不同元素顺序的嵌套 json 对象，并且希望为两者生成哈希值。现在，我正在比较这两个哈希值，它需要相同。我怎样才能实现这个机制？

第一个 json 对象

{
   "x":{
      "y":[
         {
            "a":"1",
            "b":{
               "b1":"2",
               "b2":"2"
            }
         },
         {
            "c":"4",
            "d":{
               "d1":"5",
               "d2":"6"
            }
         },
      ],
      "z":[
         {
            "e":{
               "e1":"7",
               "e2":"8"
            },
            "f":"9"
         }
      ]
   }
}

第二个 json 对象

{
   "X":{
      "Y":[
         {
            "C":"4",
            "D":{
               "d1":"5",
               "d2":"6"
            }
         },
         {
            "A":"1",
            "B":{
               "b1":"2",
               "b2":"2"
            }
         },
      ],
      "Z":[
         {
            "E":{
               "e1":"7",
               "e2":"8"
            },
            "F":"9"
         }
      ]
   }
}

所以，这里的目标是我想为两个 json 对象生成相同的哈希值。如何在 python 或 golang 中实现此目的？

正确答案

json 对象以及 map[string]interface{} 都是未排序的，因此您应该对映射进行排序。然而，排序可能会很复杂且耗时。

我不想使用对象，而是使用 json 作为字符串，这样可以对 json 进行解组，并对字符串进行排序以创建 sha 值。

var json1 = `
{
    "x": {
        "y": [
            {
                "a": "1",
                "b": {
                    "b1": "2",
                    "b2": "2"
                }
            },
            {
                "c": "4",
                "d": {
                    "d1": "5",
                    "d2": "6"
                }
            }
        ],
        "z": [
            {
                "e": {
                    "e1": "7",
                    "e2": "8"
                },
                "f": "9"
            }
        ]
    }
}
`

var json2 = `
{
    "x": {
        "y": [
            {
                "c": "4",
                "d": {
                    "d1": "5",
                    "d2": "6"
                }
            },
            {
                "a": "1",
                "b": {
                    "b1": "2",
                    "b2": "2"
                }
            }
        ],
        "z": [
            {
                "e": {
                    "e1": "7",
                    "e2": "8"
                },
                "f": "9"
            }
        ]
    }
}
`

type json struct {
    x struct {
        y []struct {
            a string `json:"a"`
            b struct {
                b1 string `json:"b1"`
                b2 string `json:"b2"`
            } `json:"b"`
            c string `json:"c"`
            d struct {
                d1 string `json:"d1"`
                d2 string `json:"d2"`
            } `json:"d"`
        } `json:"y"`
        z []struct {
            e struct {
                e1 string `json:"e1"`
                e2 string `json:"e2"`
            } `json:"e"`
            f string `json:"f"`
        } `json:"z"`
    } `json:"x"`
}

func sortstring(w string) string {
    s := strings.split(w, "")
    sort.strings(s)
    return strings.join(s, "")
}

func main() {
    var v1, v2 interface{}
    json.unmarshal([]byte(json1), &v1)
    json.unmarshal([]byte(json2), &v2)
    fmt.println(reflect.deepequal(v1, v2))

    var m1, m2 json
    json.unmarshal([]byte(json1), &m1)
    json.unmarshal([]byte(json2), &m2)
    fmt.println(reflect.deepequal(m1, m2))

    json1 = sortstring(json1)
    json2 = sortstring(json2)
    fmt.println(reflect.deepequal(json1, json2))
}

请记住，对象是未排序的，因此您应该评估创建 jsonsort 函数是否重要（考虑到 json 每次都可能不同）。

go run json.go
false
false
true

理论要掌握，实操不能落！以上关于《生成 JSON 对象的嵌套哈希值》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！