Golang 中使用 JSON 编解码进行深度相等性测试的陷阱-Golang-PHP中文网

Golang 中使用 JSON 编解码进行深度相等性测试的陷阱

心靈之曲

发布： 2025-10-17 11:51:30

原创

474人浏览过

golang 中使用 json 编解码进行深度相等性测试的陷阱

本文探讨了在 Golang 中使用 `json.Marshal` 和 `json.Unmarshal` 进行深度相等性测试时可能遇到的问题。由于 JSON 规范中只有一种数值类型（浮点数），因此在编解码过程中，整数会被转换为 `float64` 类型，导致使用 `reflect.DeepEqual` 进行比较时出现意料之外的结果。本文将深入分析这一现象，并提供避免此问题的解决方案。

在使用 Golang 进行开发时，经常需要对数据进行序列化和反序列化，json 包是常用的选择。在测试过程中，我们可能希望通过将数据序列化为 JSON 字符串，然后再反序列化回 Golang 对象，以此来验证数据的完整性和正确性。然而，直接使用 reflect.DeepEqual 对原始对象和反序列化后的对象进行深度比较，可能会遇到一些意想不到的问题。

问题分析：JSON 的数值类型

JSON 规范只定义了一种数值类型，即浮点数。这意味着，当我们将一个包含整数的 Golang 对象序列化为 JSON 字符串时，整数会被转换为浮点数。同样，当我们将 JSON 字符串反序列化回 Golang 对象时，原本的整数也会被解析为 float64 类型。

考虑以下示例：

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

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)
    }
    fmt.Println("JSON:", string(jsb)) // 输出: JSON: {"a":5}

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

    fmt.Printf("Original type: %T, Value: %v\n", in["a"], in["a"])        // 输出: Original type: int, Value: 5
    fmt.Printf("Unmarshaled type: %T, Value: %v\n", res["a"], res["a"]) // 输出: Unmarshaled type: float64, Value: 5

    // 深度比较
    if !reflect.DeepEqual(in, res) {
        fmt.Println("Not DeepEqual!") // 输出: Not DeepEqual!
    } else {
        fmt.Println("DeepEqual!")
    }
}

登录后复制

在这个例子中，原始对象 in 中的 a 字段是一个整数类型 (int)，而反序列化后的对象 res 中的 a 字段则是一个 float64 类型。因此，使用 reflect.DeepEqual 进行比较时，会返回 false，即使它们的值在数值上是相等的。

解决方案

要解决这个问题，可以考虑以下几种方法：

统一数据类型： 在序列化之前，将原始对象中的整数类型转换为 float64 类型。

Find JSON Path Online
Easily find JSON paths within JSON objects using our intuitive Json Path Finder

30

查看详情
```
in := map[string]interface{}{"a": float64(5)}
```
登录后复制
这样做可以确保序列化和反序列化后的数据类型保持一致，从而避免 reflect.DeepEqual 出现错误。
自定义比较函数： 不使用 reflect.DeepEqual，而是编写自定义的比较函数，对不同类型的数据进行特殊处理。例如，在比较数值类型时，可以先将它们转换为相同的类型，然后再进行比较。
```
func deepEqual(a, b interface{}) bool {
    aFloat, aIsFloat := a.(float64)
    bFloat, bIsFloat := b.(float64)
    aInt, aIsInt := a.(int)
    bInt, bIsInt := b.(int)

    if aIsFloat && bIsInt {
        return aFloat == float64(bInt)
    }
    if aIsInt && bIsFloat {
        return float64(aInt) == bFloat
    }
    return reflect.DeepEqual(a, b)
}
```
登录后复制
这个自定义的 deepEqual 函数会先检查两个值是否都是数值类型，如果是，则将它们转换为 float64 类型后再进行比较。
使用结构体代替 map[string]interface{}： 使用预定义的结构体可以避免类型推断带来的问题。结构体字段的类型是明确的，因此在序列化和反序列化过程中不会发生类型转换。
```
type MyStruct struct {
    A int `json:"a"`
}

in := MyStruct{A: 5}
// ... (序列化和反序列化)
```
登录后复制
使用结构体是更安全和推荐的方式，因为它提供了更好的类型安全性。

总结

在使用 Golang 的 json 包进行数据序列化和反序列化时，需要注意 JSON 的数值类型只有浮点数这一特性。如果使用 reflect.DeepEqual 对原始对象和反序列化后的对象进行深度比较，可能会因为类型不一致而导致错误。为了避免这个问题，可以采取统一数据类型、自定义比较函数或使用结构体等方法。选择合适的方法取决于具体的应用场景和需求。

以上就是Golang 中使用 JSON 编解码进行深度相等性测试的陷阱的详细内容，更多请关注php中文网其它相关文章！