十分钟掌握Go语言==运算符与reflect.DeepEqual函数处理interface{}值的比较规则

在 Go 语言中,interface{} 类型是一种特殊的接口类型,它表示任意类型的值。你可以使用 == 运算符来检测任意两个 interface{} 类型值的相等性,比较的规则和一般的接口类型一样,需要满足以下条件:

  • 两个 interface{} 值的动态类型必须相同,也就是说,它们存储的具体类型必须一致。
  • 两个 interface{} 值的动态值必须相等,也就是说,它们存储的具体值必须可以比较的。

根据 Go 语言规范的描述,interface{} 类型的值在内存中是由两个字(word)组成的,一个字存储了动态类型的信息,另一个字存储了动态值的信息。如果动态值的大小超过了一个字,那么这个字就存储了动态值的指针,指向实际的动态值。

Go 编译器是如何判定 interface{} 值是否相等的呢?

使用 == 符号比较两个 interface{} 类型的值时,Go编译器会先比较它们的动态类型,也就是比较它们的第一个字,看是否指向相同的类型信息。如果不相同直接返回 false,如果相同,则继续比较它们的动态值,也就是比较它们的第二个字,看是否相等。如果动态值的大小超过了一个字,那么这个字就是一个指针,需要根据指针找到实际的动态值,并且根据动态类型的规则进行比较。

例如,如果动态类型是数组,那么就需要逐个比较数组的元素,如果动态类型是结构体,那么就需要逐个比较结构体的字段,以此类推。

下面是一个简单的例子,演示了如何使用 == 符号比较两个 interface{} 类型的值:

package main

import "fmt"

func main() {
	var a, b interface{}
	// 给 a 赋值为 int64 类型的 1
	a = int64(1)
	// 给 b 赋值为 int64 类型的 2
	b = int64(2)
	// a和b的动态类型相同, 动态值不同, 输出结果为 false
	fmt.Println(a == b) // false

	// 给 b 赋值为 int64 类型的 1
	b = int64(1)
	// a和b的动态类型相同, 动态值也相同, 此时输出结果为true
	fmt.Println(a == b) // true

	// 给 b 赋值为 float32 类型的 1
	b = float32(1)
	// 此时a和b的动态类型不相同, 就不会进行动态值的处理, 输出结果为false
	fmt.Println(a == b) // false

	// 给 a,b 赋值为 int 类型的数组
	a = [5]int{1, 2, 3, 4, 5}
	b = [5]int{1, 2, 3, 4, 5}
	fmt.Println(a == b) // true

	// 给 b 赋值为 int 类型的数组
	b = [5]int{1, 2, 3, 4, 6}
	fmt.Println(a == b) // false

	// 给 b 赋值为 int 类型的切片
	b = []int{1, 2, 3, 4, 5}
	// 此时a和b的动态类型已然不相同, 就不会进行动态值的处理, 输出结果为false
	fmt.Println(a == b) // false

	// 给 a 赋值为 int 类型的切片
	a = []int{1, 2, 3, 4, 5}
	// 此时a和b的动态类型和动态值虽然相同, 但是在Go语言中切片类型的值是不能用 == 符号比较,会引发运行时错误
	//fmt.Println(a == b) // panic: runtime error: comparing uncomparable type []int
}

== 运算符通常只能用于比较基本类型和支持 == 操作的复合类型,如数组、结构体等,而不能用于比较切片、映射、函数等类型,否则会引发编译错误或运行时错误。

那么问题来了,如果一定要比较两个切片、映射、函数的相等性,该如何操作呢?

reflect.DeepEqual 函数原型:

// 用于判断两个值是否深度一致
// 
// 除了类型相同;在可以时(主要是基本类型)会使用==;但还会比较array、slice的成员,
// map的键值对,结构体字段进行深入比对。map的键值对,对键只使用==,但值会继续往深
// 层比对。DeepEqual函数可以正确处理循环的类型。函数类型只有都会nil时才相等;空切
// 片不等于nil切片;还会考虑array、slice的长度、map键值对数。
func DeepEqual(x, y any) bool

对于 reflect.DeepEqual 而言,它通过牺牲程序的性能来弥补 == 运算符无法处理切片、映射、函数的短板,对于不支持 == 操作的类型,reflect.DeepEqual 函数会有一套自己的比较规则。

下面是一个简单的例子,演示了如何使用 reflect.DeepEqual 函数:

package main

import "fmt"

func main() {
	var a, b interface{}
	// 给 a 赋值为 int64 类型的 1
	a = int64(1)
	// 给 b 赋值为 int64 类型的 2
	b = int64(2)
	fmt.Println(a == b, reflect.DeepEqual(a, b))

	b = int64(1)
	fmt.Println(a == b, reflect.DeepEqual(a, b))

	b = float32(1)
	fmt.Println(a == b, reflect.DeepEqual(a, b))

	// 给 b 赋值为 int 类型的切片
	a, b = []int{1, 2, 3, 4, 5}, []int{1, 2, 3, 4, 5}
	fmt.Println(reflect.DeepEqual(a, b)) // true

	b = []int{5, 4, 3, 2, 1}
	fmt.Println(reflect.DeepEqual(a, b)) // false
}

你可能感兴趣的:(GoLang不懂就问系列,golang,开发语言,后端,go)