Go 语言类型可比性

前段时间，一位读者私信了我一个 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