概述

比较运算符 用来比较两个操作数并返回一个 bool 值，常见的比较运算符:

==    等于
!=    不等于
<     小于
<=    小于等于
>     大于
>=    大于等于

在任何比较中，第一个操作数必须可以赋值给第二个操作数的类型，反过来也一样。

不可比较类型

Go 中有 3 种数据类型不能比较，分别是 slice, map, func，如果要比较这 3 种类型，使用 reflect.DeepEqual 函数。

为什么 slice 不能比较

(个人猜测，待验证)

• 切片是引用类型，比较地址没有意义
• 多个切片引用同一数组时，修改时会相互影响，无法保证 key 的一致性
• 切片除了 len 属性外，还有 cap 属性，比较的维度没办法精确衡量

基于上述原因，官方没有支持 slice 类型的比较。

为什么 map 不能比较

(个人猜测，待验证)

• map 遍历是随机的，无法保证 key 的一致性

为什么 func 不能比较

(个人猜测，待验证)

• 函数的可变参数机制，无法保证 key 的一致性
• 函数参数可以为 slice, map, 这两种类型不可比较

可比较类型的具体规则

• 布尔值 可比较
• 整型 可比较
• 浮点型 可比较。如果两个浮点型值一样 (由 IEEE-754 标准定义)，则两者相等
• 复数型 可比较。如果两个复数型值的 real() 方法和 imag() 方法都相等，则两者相等
• 字符串 可比较
• 指针 可比较。如果两个指针指向相同的 地址 或者两者都为 nil，则两者相等，但是指向不同的零大小变量的指针可能不相等
• 通道 可比较。如果两个通道是由同一个 make 创建的 (引用的是同一个 channel 指针)，或者两者都为 nil, 则两者相等
• 接口 可比较。interface 的内部实现包含了 2 个字段，类型 T 和值 V。如果两个 接口 具有相同的动态类型和动态值，或者两者都为 nil, 则两者相等
• 结构体 可比较 (如果两个结构体的所有字段都是可比较的)。如果两个结构体对应的非空白字段相等，则两者相等
• 数组 可比较 (如果两个数组的所有元素都是可比较的)。如果两个数组的所有对应元素相等，则两者相等

例子

指针的比较

指向相同的地址的指针

package main

import "fmt"

func main() {
    n := 1024
    p := &n
    p2 := &n
    fmt.Printf("p == p2: %t\n", p == p2)
}

// $ go run main.go
// 输出如下
/**
  p == p2: true
*/

指向 nil 的指针

package main

import "fmt"

func main() {
    var p *string
    var p2 *string
    fmt.Printf("p == p2: %t\n", p == p2)
}

// $ go run main.go
// 输出如下
/**
  p == p2: true
*/

通道的比较

同一个 make() 创建的通道

package main

import "fmt"

func main() {
    ch := make(chan bool)
    ch2 := make(chan bool)

    p := &ch
    p2 := &ch2
    fmt.Printf("p == p2: %t\n", p == p2)

    p3 := &ch
    fmt.Printf("p == p3: %t\n", p == p3)
}

// $ go run main.go
// 输出如下
/**
  p == p2: false
  p == p3: true
*/

通道为 nil

package main

import "fmt"

func main() {
    var p *chan bool
    var p2 *chan bool

    fmt.Printf("p == p2: %t\n", p == p2)
}

// $ go run main.go
// 输出如下
/**
  p == p2: true
*/

结构体的比较

比较的前提: 两个结构体的所有字段都是可比较的，相等是指: 字段类型、字段个数、字段顺序、字段值完全一致。

结构体对应的非空白字段相等

package main

import "fmt"

type person struct {
    name string
    age  int
}

func main() {
    tom := person{
        name: "Tom",
        age:  6,
    }
    jerry := person{
        name: "Jerry",
        age:  8,
    }
    fmt.Printf("tom == jerry: %t\n", tom == jerry)

    nobody := person{}
    nobody2 := person{}

    fmt.Printf("nobody == nobody2: %t\n", nobody == nobody2)
}

// $ go run main.go
// 输出如下
/**
  tom == jerry: false
  nobody == nobody2: true
*/

结构体为 nil

package main

import "fmt"

type person struct {
    name string
    age  int
}

func main() {
    var nobody person
    var nobody2 person

    fmt.Printf("nobody == nobody2: %t\n", nobody == nobody2)
}

// $ go run main.go
// 输出如下
/**
  nobody == nobody2: true
*/

接口的比较

具有相同的动态类型和动态值

package main

import "fmt"

type person struct {
    name string
}

func main() {
    var tom1, tom2 interface{}

    tom1 = &person{"Tom"}
    tom2 = &person{"Tom"}

    var tom3, tom4 interface{}
    tom3 = person{"Tom"}
    tom4 = person{"Tom"}

    fmt.Printf("tom1 == tom2: %t\n", tom1 == tom2) // false
    fmt.Printf("tom3 == tom4: %t\n", tom3 == tom4) // true
}

// $ go run main.go
// 输出如下
/**
  tom1 == tom2: false
  tom3 == tom4: true
*/

上面的示例代码中，tom1 和 tom2 对应的类型是 *person，值是 person 结构体的地址，但是两个地址不同，因此两者不相等, tom3 和 tom4 对应的类型是 person，值是 person 结构体且各字段相等，因此两者相等。

接口为 nil

package main

import "fmt"

func main() {
    var tom1, tom2 interface{}
    fmt.Printf("tom1 == tom2: %t\n", tom1 == tom2) // true
}

// $ go run main.go
// 输出如下
/**
  tom1 == tom2: true
*/

小结

本小节介绍了 Go 的比较运算符以及各种数据类型的比较规则。Go 中大多数数据类型都是可以比较的，除了 slice, map, func 这 3 种，对于不能比较的原因，笔者给出了一些猜测，感兴趣的读者可以自行验证。限于时间和篇幅，没有给出所有数据类型的代码示例，读者可以编写代码验证具体的类型比较规则。

Go 快速入门指南 - 类型比较

概述

不可比较类型

为什么 slice 不能比较

为什么 map 不能比较

为什么 func 不能比较

可比较类型的具体规则

例子

指针的比较

指向相同的地址的指针

指向 nil 的指针

通道的比较

同一个 make() 创建的通道

通道为 nil

结构体的比较

结构体对应的非空白字段相等

结构体为 nil

接口的比较

具有相同的动态类型和动态值

接口为 nil

小结