文章目录
go 语言中的可比较类型和不可比较类型
操作符 | 变量类型 |
---|---|
等值操作符 (==、!=) | 整型、浮点型、字符串、布尔型、复数、指针、管道、接口、结构体、数组 |
排序操作符 (<、<=、> 、 >=) | 整型、浮点型、字符串 |
不可比较类型 | map、slice、function |
一、为什么关心可比较性
1、比较操作符
比较操作符分为等值操作符(== 和 !=)和排序操作符(<、<=、> 、 >=),等值操作符作用的操作数必须是可比较的,排序操作符作用的操作数必须是可排序的。
2、关心可比较性的原因
编写程序时,将变量进行比较是非常普遍的操作,因为 Go 语言对某些类型的比较做了严格的限制,如果错误的将两个变量进行比较,编译器有可能无法识别,进而产生运行时错误,即 panic。
有些无法比较的,编译器能够拦截,例如使用排序操作符时,如果两个变量是无法比较的(不能分出大小),编译器能够给出错误提示。但对于等值操作符,如果两个操作数无法比较,编译器则不能保证一定能够识别,例如接口类型的变量比较时,编译器不会给出错误提示,只有运行时才能够判断是否可比较,此时有错误就会引起程序崩溃。所以了解类型的可比较性就非常重要了。
二、可比较类型
Go 语言中可以进行等值比较的类型包括布尔类型、整型、浮点型、字符串类型、复数类型、指针类型、管道类型、接口类型、结构体类型和数组类型。其中布尔类型、整型比较常见且易于理解,在此不做过多赘述,下面着重介绍其他类型,因为它们或多或少都有值得注意的地方。
1、正常的类型
- 浮点型
Go 语言中两个浮点型变量可以直接比较,Go 语言的浮点型参照的是 IEEE(电气与电子工程师协会)754 号标准,也即二进制浮点数算术标准,两个符点数在一定精度下无法区分大小即相等。这个标准并不是被所有编程语言所采用,比如 C 语言,它诞生时间比这个标准还要早,在 C 语言的实现中浮点数是不能进行等值比较的。
f1 := 0.10
f2 := 0.1
fmt.Println(f1 == f2) // 输出 true
fmt.Println(f1 < f2) // 输出 false
- 字符串类型
string 类型比较是按字节逐个比较的,当两个 string 变量所有字节值都相等时,两个 string 变量则相等。做等值比较时,第一个字节不相等,则直接判定为不相等;做排序比较时,第一个字节值小于,则直接判定为小于。
s1 := "中" // Unicode 编码占 3 个字节:228,184,173
s2 := "国" // Unicode 编码占 3 个字节:229,155,189
fmt.Println(s1 == s2) // 输出 false
fmt.Println(s1 < s2) // 输出 true
- 复数类型
复数类型是可以比较的,复数类型的实部和虚部由浮点数进行表示,只有当两个复数实部和虚部都相等才相等。
c1 := complex(1, 2)
c2 := complex(1, 2)
c3 := complex(1, 3)
fmt.Println(c1 == c2) // 输出 true
fmt.Println(c1 == c3) // 输出 false
fmt.Println(c1 < c2)
// 错误提示:Invalid operation: c1 < c2 (the operator < is not defined on complex128)
- 指针类型
指针本质上是个整型,其值反映的是内存地址,因此指针类型是可以比较的,两个指针变量如果指向的地址相同(或同为 nil)则认为相等,否则不相等,两个指针相等则代表指向同一块内存。
str1 := "Hello World"
p1 := &str1
str2 := "Hello World"
p2 := &str2
fmt.Println(p1 == p2) // 输出 false
fmt.Println(p1 < p2)
// 错误提示:Invalid operation: p1 < p2 (the operator < is not defined on *string)
- 管道类型
管道是可以比较的,管道本质上是个指针,make 语句生成的是一个管道的指针,所以管道的比较规则与指针相同,两个管道变量如果是同一个 make 语句声明(或同为 nil)则两个管道相等,否则不等。
cha := make(chan int, 10)
chb := make(chan int, 10)
chc := cha
fmt.Println(cha == chb) // 输出 false
fmt.Println(cha == chc) // 输出 true
// 管道 cha 和 chb 虽然类型和空间完全相同,但由于出自不同的 make 语句,所以两个管道不相等
// 但管道 chc 由于获得了管道 cha 的地址,所以管道 cha 和 chc 相等
fmt.Println(cha < chc)
// 错误提示:Invalid operation: cha < chc (the operator < is not defined on chan int)
- 数组类型
数组类型是可以比较的,如果两个数组类型(元素类型和声明长度)相同、每个元素均相同,则两个数组相等,否则不等。
arr1 := [10]int{1, 2, 3}
arr2 := [10]int{1, 2}
fmt.Println(arr1 == arr2) // 输出 false
arr2[2] = 3
fmt.Println(arr1 == arr2) // 输出 true
fmt.Println(arr1 < arr2)
// 错误提示:Invalid operation: arr1 < arr2 (the operator < is not defined on [10]int)
2、需要特别注意的类型
- 结构体类型
结构体是可以比较的,但前提是结构体成员字段全部可以比较,并且结构体成员字段类型、个数、顺序也需要相同,当结构体成员全部相等时,两个结构体相等。
特别注意的点,如果结构体成员字段的顺序不相同,那么结构体也是不可以比较的。如果结构体成员字段中有不可以比较的类型,如map、slice、function 等,那么结构体也是不可以比较的。
func main() {
sn1 := struct {
age int
name string
}{age: 11, name: "Zhang San"}
sn2 := struct {
age int
name string
}{age: 11, name: "Zhang San"}
fmt.Println(sn1 == sn2) // 输出 true
sn3 := struct {
name string
age int
}{age: 11, name: "Zhang San"}
fmt.Println(sn1 == sn3)
// 错误提示:Invalid operation: sn1 == sn3 (mismatched types struct {...} and struct {...})
sn4 := struct {
name string
age int
grade map[string]int
}{age: 11, name: "Zhang San"}
sn5 := struct {
name string
age int
grade map[string]int
}{age: 11, name: "Zhang San"}
fmt.Println(sn4 == sn5)
// 错误提示:Invalid operation: sn4 == sn5 (the operator == is not defined on struct {...})
}
- 接口类型
Go 语言中,接口(interface)是对非接口值(例如指针,struct 等)的封装,内部实现包含了 2 个字段,类型 T 和 值 V。
type iface struct {
tab *itab // 保存变量类型(以及方法集)
data unsafe.Pointer // 变量值位于堆栈的指针
}
接口是由 struct 表示的,所谓的底层类型即 iface.tab 字段,而底层值即 iface.data,因此接口类型的比较就演变成了结构体比较。
两个接口类型比较时,会先比较 T,再比较 V。接口类型与非接口类型比较时,会先将非接口类型尝试转换为接口类型,再按接口比较的规则进行比较。如果两个接口变量底层类型和值完全相同(或同为 nil)则两个变量相等,否则不等。
接口类型比较时,如果底层类型不可比较,则会发生 panic。
package main
import "fmt"
type Animal interface {
Speak() string
}
type Duck struct {
Name string
}
func (a Duck) Speak() string {
return "I'm " + a.Name
}
type Cat struct {
Name string
}
func (a Cat) Speak() string {
return "I'm " + a.Name
}
type Bird struct {
Name string
SpeakFunc func() string
}
func (a Bird) Speak() string {
return "I'm " + a.SpeakFunc()
}
// Animal 为接口类型,Duck 和 Cat 分别实现了该接口。
func main() {
var d1, d2, c1 Animal
d1 = Duck{Name: "Donald Duck"}
d2 = Duck{Name: "Donald Duck"}
c1 = Cat{Name: "Donald Duck"}
fmt.Println(d1 == d2) // 输出 true
fmt.Println(d1 == c1) // 输出 false
// 接口变量 d1、d2 底层类型同为 Duck 并且底层值相同,所以 d1 和 d2 相等。
// 接口变量 c1 底层类型为 Cat,尽管底层值相同,但类型不同,c1 与 d1 也不相等。
var animal Animal
animal = Duck{Name: "Donald Duck"}
var duck Duck
duck = Duck{Name: "Donald Duck"}
fmt.Println(animal == duck) // 输出 true
// 当 struct 和接口进行比较时,可以简单地把 struct 转换成接口然后再按接口比较的规则进行判定。
// animal 为接口变量,而 duck 为 struct 变量,底层类型同为 Duck 并且底层值相同,二者判定为相等。
var b1 Animal = Bird{
Name: "bird",
SpeakFunc: func() string {
return "I'm Poly"
}}
var b2 Animal = Bird{
Name: "bird",
SpeakFunc: func() string {
return "I'm eagle"
}}
fmt.Println(b1 == b2)
// panic: runtime error: comparing uncomparable type main.Bird
// 结构体 Bird 也实现了 Animal 接口,但结构体中增加了一个不可比较的函数类型成员 SpeakFunc,
// 因此 Bird 变成了不可比较类型,接口类型变量 b1 和 b2 底层类型为 Bird,在比较时会触发 panic。
}
- nil 类型
2 个 nil 类型可能不相等,两个nil 只有在类型相同时才相等。例如,interface 在运行时绑定值,只有值为 nil 接口值才为 nil,但是与指针的 nil 不相等。
func main() {
var p *int = nil
var i interface{}
fmt.Println(p == nil) // 输出 true
fmt.Println(i == nil) // 输出 true
fmt.Println(i == p) // 输出 false
}
三、不可比较类型
Go 语言只有三种不可比较类型,分别是 slice、map、function,三种类型的变量不能进行比较,只有一个例外:可以与 nil 进行比较。
func main() {
aSlice := make([]string, 0)
bSlice := make([]string, 0)
aMap := make(map[string]int)
bMap := make(map[string]int)
aFunc := func() {}
bFunc := func() {}
fmt.Println(aSlice == bSlice)
// 错误提示:Invalid operation: aSlice == bSlice (the operator == is not defined on []string)
fmt.Println(aMap == bMap)
// 错误提示:Invalid operation: aMap == bMap (the operator == is not defined on map[string]int)
fmt.Println(aFunc == bFunc)
// 错误提示:Invalid operation: aFunc == bFunc (the operator == is not defined on func())
}
1、不可比较的原因
至于这三种类型为什么不可比较,Golang 社区没有给出官方解释,经过分析,可能是因为 比较的维度不好衡量,难以定义一种没有争议的比较规则。所以 go 官方并没有定义比较运算符(==和!=),而是只能与nil进行比较。
比如两个 slice 类型相同、长度相同并且元素值也相同算不算相等?如果说相等,那么如果两个 slice 地址不同,还算不算相等呢?答案就可能无法统一了。至于 map 也是同样的道理。另外再看 function,两个函数实现功能一样,但实现逻辑不一样算不算相等呢?可见,这三种类型的比较容易引入歧义。
2、实现比较的方法
使用 reflect.TypeOf(value).Comparable() 判断可否进行比较, 使用 reflect.DeepEqual(value 1, value 2) 进行比较,当然也有特殊情况,例如 []byte,通过 bytes. Equal 函数进行比较。但是反射非常影响性能。
func main() {
s := "Hello World"
aMap := make(map[string]int)
bMap := make(map[string]int)
fmt.Println(reflect.TypeOf(s).Comparable()) // 输出 true
fmt.Println(reflect.TypeOf(aMap).Comparable()) // 输出 false
fmt.Println(reflect.TypeOf(bMap).Comparable()) // 输出 false
fmt.Println(reflect.DeepEqual(aMap, bMap)) // 输出 true
aMap["s"] = 1
fmt.Println(reflect.DeepEqual(aMap, bMap)) // 输出 false
}
四、总结
本博客我们着重介绍了 go 语言中类型的可比较性,即各种类型在面对 == 和 != 操作符的比较规则,只有三种类型(切片、map 和函数)三种类型不可比较,尽管接口类型可以比较,但要警惕如果底层类型不可比较可能会引起程序崩溃的问题。
对于类型的可排序性,即类型在面对 <、<=、> 和 >= 时的比较规则,也只有三种类型(整型、浮点型和字符串)可以比较,而且即便误用,编译器也能够帮忙拦截。