前段时间,一位读者私信了我一个 Go 代码例子,并问我这是不是一个 bug。我觉得蛮有意思的,故整理出了本文的分享内容。
在讨论代码之前,读者需要有一些前置知识。
Go 可比较类型
在 Go 中,数据类型可以被分为两类,可比较与不可比较。两者区分非常简单:类型是否可以使用运算符 == 和 != 进行比较。
那哪些类型是可比较的呢?
- Boolean(布尔值)、Integer(整型)、Floating-point(浮点数)、Complex(复数)、String(字符)这些类型是毫无疑问可以比较的。
- Poniter (指针) 可以比较:如果两个指针指向同一个变量,或者两个指针类型相同且值都为 nil,则它们相等。注意,指向不同的零大小变量的指针可能相等,也可能不相等。
- Channel (通道)具有可比性:如果两个通道值是由同一个 make 调用创建的,则它们相等。
- c1 := make(chan int, 2)
- c2 := make(chan int, 2)
- c3 := c1
- fmt.Println(c3 == c1) // true
- fmt.Println(c2 == c1) // false
- Interface (接口值)具有可比性:如果两个接口值具有相同的动态类型和相等的动态值,则它们相等。
- 当类型 X 的值具有可比性且 X 实现 T 时,非接口类型 X 的值 x 和接口类型 T 的值 t 具有可比性。如果 t 的动态类型与 X 相同且 t 的动态值等于 x,则它们相等。
- 如果所有字段都具有可比性,则 struct (结构体值)具有可比性:如果它们对应的非空字段相等,则两个结构体值相等。
- 如果 array(数组)元素类型的值是可比较的,则数组值是可比较的:如果它们对应的元素相等,则两个数组值相等。
哪些类型是不可比较的?
- slice、map、function 这些是不可以比较的,但是也有特殊情况,那就是当他们值是 nil 时,可以与 nil 进行比较。
动态类型
在上文接口可比性中,我们提到了动态类型与动态值,这里需要介绍一下。
常规变量(非接口)的类型是由声明所定义,这是静态类型,例如 var x int。
接口类型的变量有一个独特的动态类型,它是运行时存储在变量中的值的实际类型。动态类型在执行过程中可能会有所不同,但始终可以分配给接口变量一个静态类型。
例如
- var someVariable interface{} = 101
someVariable 变量的静态类型是 interface{},但是它的动态类型是 int,并且很可能在之后发生变化。
- var someVariable interface{} = 101
- someVariable = 'Gopher'
如上, someVariable 变量的动态类型从 int 变为了 string。
代码场景示例
我们为当前业务所需的数据模型定义一个结构体 Data,它包含两个字段:一个 string 类型的 UUID 和 interface{} 类型的 Content。
- type Data struct {
- UUID string
- Content interface{}
- }
根据上文介绍, string 类型和 interface 是可比较类型,那么两个 Data 类型的数据,我们可以通过 == 操作符进行比较。
- var x, y Data
- x = Data{
- UUID: "856f5555806443e98b7ed04c5a9d6a9a",
- Content: 1,
- }
- y = Data{
- UUID: "745dee7719304991862e6985ea9c02a9",
- Content: 2,
- }
- fmt.Println(x == y)
但是,如果在 Content 中的动态类型是 map 会怎样?
- var m, n Data
- m = Data{
- UUID: "9584dba3fe26418d86252d71a5d78049",
- Content: map[int]string{1: "GO", 2: "Python"},
- }
- n = Data{
- UUID: "9584dba3fe26418d86252d71a5d78049",
- Content: map[int]string{1: "GO", 2: "Python"},
- }
- fmt.Println(m == n)
此时,我们程序编译通过,但会发生运行时错误。
- panic: runtime error: comparing uncomparable type map[int]string
那针对这种需求:即对于不可比较类型,因为不能使用比较操作符 ==,但我们想要比较它们包含的值是否相等时,应该怎么办。
此时我们可以采用 reflect.DeepEqual 函数进行比较,即将上述的 m==n 替换
- fmt.Println(reflect.DeepEqual(m,n)) // true
我们得出结论:如果我们的变量中包含不可比较类型,或者 interface 类型(它的动态类型可能存在不可比较的情况),那么我们直接运用比较运算符 == ,会引发程序错误。此时应该选用 reflect.DeepEqual 函数(当然也有特殊情况,例如 []byte,可以通过 bytes. Equal 函数进行比较)。
Bug 代码?
好,铺垫了这么久,终于可以展示读者给我的代码了。
- var x, y Data
- x = Data{
- UUID: "856f5555806443e98b7ed04c5a9d6a9a",
- Content: 1,
- }
- bytes, _ := json.Marshal(x)
- _ = json.Unmarshal(bytes, &y)
- fmt.Println(x) // {856f5555806443e98b7ed04c5a9d6a9a 1}
- fmt.Println(y) // {856f5555806443e98b7ed04c5a9d6a9a 1}
- fmt.Println(reflect.DeepEqual(x, y)) // false
对于同一个原始数据,经过 json 的 Marshal 和 Unmarshal 过程后,竟然不相等了?难道有 bug?
不慌,这种时候,我们直接上调试看看。
debug
原来此 1 非彼 1,Content 字段的数据类型由 int 转换为了 float64 。而在接口中,其动态类型不一致时,它的比较是不相等的。
经过排查,发现问题就出在 Unmarshal 函数上:如果要将 Json 对象 Unmarshal 为接口值,那么它的类型转换规则如下
Unmarshal
可以看到,数值型的 json 解析操作统一为了 float64。
因此,如果我们将 Content: 1 改为 Content: 1.0 ,那么它 reflect.DeepEqual(x, y) 的值将是 true。
增强型 DeepEqual 函数
针对 json 解析的这种类型改变特性,我们可以基于 reflect.DeepEqual 函数进行改造适配。
- func DeepEqual(v1, v2 interface{}) bool {
- if reflect.DeepEqual(v1, v2) {
- return true
- }
- bytesA, _ := json.Marshal(v1)
- bytesB, _ := json.Marshal(v2)
- return bytes.Equal(bytesA, bytesB)
- }
当我们使用增强后的函数来运行上述的 “bug” 例子
- var x, y Data
- x = Data{
- UUID: "856f5555806443e98b7ed04c5a9d6a9a",
- Content: 1,
- }
- b, _ := json.Marshal(x)
- _ = json.Unmarshal(b, &y)
- fmt.Println(DeepEqual(x, y)) // true
此时,结果符合我们的预期。
结论
本文讨论了 Go 的可比较与不可比较类型,并对静态、动态类型进行了阐述。
不可比较类型包括 slice、map、function,它们不能使用 == 进行比较。虽然我们可以通过 == 操作符对 interface 进行比较,由于动态类型的存在,如果实现 interface 的 T 有不可比较类型,这将引起运行时错误。
在不能确定 interface 的实现类型的情况下,对 interface 的比较,可以使用 reflect.DeepEqual 函数。
最后,我们通过 json 库的解析与反解析过程中,发现了 json 解析存在数据类型转换操作。这一个细节,读者在使用过程中需要注意,以免产生想法“这代码有 bug” 。
参考
https://golang.org/ref/spec#Comparison_operators
https://golang.org/ref/spec#Types
https://pkg.go.dev/encoding/json#Unmarshal