Golang 中使用 JSON 序列化进行深度相等性测试的陷阱-Golang-PHP中文网

Golang 中使用 JSON 序列化进行深度相等性测试的陷阱

DDD

发布： 2025-10-17 12:09:18

原创

318人浏览过

golang 中使用 json 序列化进行深度相等性测试的陷阱

在使用 Golang 的 json.Marshal 和 json.Unmarshal 进行深度相等性测试时，需要注意 JSON 的数值类型特性。由于 JSON 仅支持浮点数类型，因此整数在序列化和反序列化过程中会被转换为 float64 类型，这会导致使用 reflect.DeepEqual 进行比较时出现意外的结果。本文将深入探讨这个问题，并提供解决方案。

问题分析

在 Golang 中，我们经常需要对复杂的数据结构进行比较，判断它们是否相等。一种常见的做法是先将数据结构序列化为 JSON 字符串，然后再反序列化回 Golang 的数据结构，最后使用 reflect.DeepEqual 函数进行比较。然而，这种方法在处理包含数值类型的数据时可能会遇到问题。

例如，以下代码：

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

func main() {
    in := map[string]interface{}{"a": 5}

    // 序列化为 JSON 字符串
    jsb, err := json.Marshal(in)
    if err != nil {
        panic(err)
    }

    // 反序列化为 map
    res := make(map[string]interface{})
    if err := json.Unmarshal(jsb, &res); err != nil {
        panic(err)
    }

    // 比较
    fmt.Println(reflect.DeepEqual(in, res)) // 输出: false
    fmt.Printf("in['a'] type: %T, value: %v\n", in["a"], in["a"])
    fmt.Printf("res['a'] type: %T, value: %v\n", res["a"], res["a"])
}

登录后复制

运行这段代码，我们会发现 reflect.DeepEqual(in, res) 的结果是 false。这是因为 in["a"] 的类型是 int，而 res["a"] 的类型是 float64。由于 JSON 规范只支持浮点数类型的数值，因此在反序列化时，整数 5 被转换为了浮点数 5.0。

立即学习“go语言免费学习笔记（深入）”；

解决方案

为了解决这个问题，我们需要在比较之前将 res 中的 float64 类型的值转换为 int 类型，或者将 in 中的 int 类型的值转换为 float64 类型。以下是一些可能的解决方案：

1. 类型断言和转换：

讯飞开放平台

科大讯飞推出的以语音交互技术为核心的AI开放平台

152

查看详情

在比较之前，遍历 res 映射，如果发现某个值是 float64 类型，则尝试将其转换为 int 类型。

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

func main() {
    in := map[string]interface{}{"a": 5}

    // 序列化为 JSON 字符串
    jsb, err := json.Marshal(in)
    if err != nil {
        panic(err)
    }

    // 反序列化为 map
    res := make(map[string]interface{})
    if err := json.Unmarshal(jsb, &res); err != nil {
        panic(err)
    }

    // 类型转换
    for k, v := range res {
        if f, ok := v.(float64); ok {
            res[k] = int(f)
        }
    }

    // 比较
    fmt.Println(reflect.DeepEqual(in, res)) // 输出: true
}

登录后复制

2. 使用自定义的 Unmarshal 函数：

可以自定义一个 Unmarshal 函数，在反序列化时将浮点数转换为整数。

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

// CustomUnmarshal 自定义反序列化函数
func CustomUnmarshal(data []byte, v interface{}) error {
    var i interface{}
    if err := json.Unmarshal(data, &i); err != nil {
        return err
    }

    // 递归处理，将 float64 转换为 int
    convertFloatToInt(i)

    // 将处理后的数据赋值给 v
    reflect.ValueOf(v).Elem().Set(reflect.ValueOf(i))
    return nil
}

// convertFloatToInt 递归转换函数
func convertFloatToInt(i interface{}) {
    switch v := i.(type) {
    case map[string]interface{}:
        for key, val := range v {
            if f, ok := val.(float64); ok {
                v[key] = int(f)
            } else {
                convertFloatToInt(val)
            }
        }
    case []interface{}:
        for _, val := range v {
            convertFloatToInt(val)
        }
    }
}

func main() {
    in := map[string]interface{}{"a": 5, "b": 5.5, "c": []interface{}{1, 2.5, map[string]interface{}{"d": 3.5}}}

    // 序列化为 JSON 字符串
    jsb, err := json.Marshal(in)
    if err != nil {
        panic(err)
    }

    // 反序列化为 map
    res := make(map[string]interface{})
    if err := CustomUnmarshal(jsb, &res); err != nil {
        panic(err)
    }

    // 比较
    fmt.Println(reflect.DeepEqual(in, res)) // 输出: false
    fmt.Printf("in: %#v\n", in)
    fmt.Printf("res: %#v\n", res)

}

登录后复制

3. 使用第三方库：

可以使用一些第三方库，例如 github.com/mitchellh/mapstructure，它可以更灵活地进行类型转换。

package main

import (
    "encoding/json"
    "fmt"
    "reflect"

    "github.com/mitchellh/mapstructure"
)

func main() {
    in := map[string]interface{}{"a": 5}

    // 序列化为 JSON 字符串
    jsb, err := json.Marshal(in)
    if err != nil {
        panic(err)
    }

    // 反序列化为 map
    var res map[string]interface{}
    if err := json.Unmarshal(jsb, &res); err != nil {
        panic(err)
    }

    // 使用 mapstructure 进行类型转换
    var convertedRes map[string]interface{}
    config := &mapstructure.DecoderConfig{
        Result:      &convertedRes,
        TagName:     "json",
        WeaklyTypedInput: true, // 允许弱类型转换
    }
    decoder, err := mapstructure.NewDecoder(config)
    if err != nil {
        panic(err)
    }
    err = decoder.Decode(res)
    if err != nil {
        panic(err)
    }

    // 比较
    fmt.Println(reflect.DeepEqual(in, convertedRes)) // 输出: true
}

登录后复制