在使用 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. 类型断言和转换：
在比较之前，遍历 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
}注意事项
- 在选择解决方案时，需要根据实际情况进行权衡。如果数据结构比较简单，可以使用类型断言和转换；如果数据结构比较复杂，可以考虑使用自定义的 Unmarshal 函数或第三方库。
- 使用 WeaklyTypedInput: true 可能会导致一些非预期的类型转换，需要仔细测试。
总结
在使用 Golang 的 json.Marshal 和 json.Unmarshal 进行深度相等性测试时，需要注意 JSON 的数值类型特性。通过类型转换或其他方法，可以避免由于数据类型不一致而导致的比较错误。 选择合适的解决方案可以确保深度相等性测试的准确性和可靠性。
