这可能是最全的golang的"=="比较规则了吧

背景交代

大家经常用"=="来比较两个变量是否相等。但是golang中的"=="有很多细节的地方,跟php是不一样的。很多时候不能直接用"=="来比较,编译器会直接报错。

golang中基本类型的比较规则和复合类型的不一致,先介绍下golang的变量类型:

  • 1,基本类型
    • 整型,包括int,uint,int8,uint8,int16,uint16,int32,uint32,int64,uint64,byte,rune,uintptr等
    • 浮点型,包括float32,float64
    • 复数类型,包括complex64,complex128
    • 字符串类型,string
    • 布尔型,bool
  • 2,复合类型
    • 数组
    • struct结构体
  • 3,引用类型
    • slice
    • map
    • channel
    • pointer or 引用类型
  • 4,接口类型
    io.Reader, io.Writer,error等

一,基本类型的变量比较

golang中的基本类型

比较的两个变量类型必须相等。而且,golang没有隐式类型转换,比较的两个变量必须类型完全一样,类型别名也不行。如果要比较,先做类型转换再比较。

  • 类型完全不一样的,不能比较
  • 类型再定义关系,不能比较,可以强转比较
  • 类型别名关系,可以比较
    fmt.Println("2" == 2) //invalid operation: "2" == 2 (mismatched types string and int)

    type A int
    var a int = 1
    var b A = 1
    fmt.Println(a == b) //invalid operation: a == b (mismatched types int and A)
    fmt.Println(a == int(b)) //true

    type C = int
    var c C = 1
    fmt.Println(a == c) //true

二,复合类型的变量比较

复合类型是逐个字段,逐个元素比较的。需要注意的是,array 或者struct中每个元素必须要是可比较的,如果某个array的元素 or struct的成员不能比较(比如是后面介绍的slice,map等),则此复合类型也不能比较。

1,数组类型变量比较

  • 数组的长度是类型的一部分,如果数组长度不同,无法比较
  • 逐个元素比较类型和值。每个对应元素的比较遵循基本类型变量的比较规则。跟struct一样,如果item是不可比较的类型,则array也不能做比较。

2,struct类型变量比较

逐个成员比较类型和值。每个对应成员的比较遵循基本类型变量的比较规则。

    type Student struct {
        Name string
        Age  int
    }

    a := Student{"minping", 30}
    b := Student{"minping", 30}
    fmt.Println(a == b)   //true
    fmt.Println(&a == &b) //false

但是如果struct中有不可比较的成员类型时:

type Student struct {
        Name string
        Age  int
        Info []string
    }

    a := Student{
        Name: "minping",
        Age:  30,
    }
    b := Student{
        Name: "minping",
        Age:  30,
    }
    fmt.Println(a == b)   //invalid operation: a == b (struct containing []string cannot be compared)

可以看到,struct中有slice这种不可比较的成员时,整个struct都不能做比较,即使没有对slice那个成员赋值(slice默认值为nil)

三,引用类型的变量比较

slice和map的比较规则比较奇怪,我们先说普通的变量引用类型&val和channel的比较规则。

1,普通的变量引用类型&val和channel的比较规则

引用类型变量存储的是某个变量的内存地址。所以引用类型变量的比较,判断的是这两个引用类型存储的是不是同一个变量。

  • 如果是同一个变量,则内存地址肯定也一样,则引用类型变量相等,用"=="判断为true
  • 如果不是同一个变量,则内存地址肯定不一样,"=="结果为false

上面看起来比较废话,但是得理解引用类型的含义。不然对判断规则还是不清楚。

type Student struct {
        Name string
        Age  int
    }

    a := &Student{"minping", 30}

    b := &Student{"minping", 30}
    fmt.Println(a == b) //false

    c := a
    fmt.Println(a == c) //true
        
        //作为引用类型,channel和普通的&val判断规则一致
        ch1 := make(chan int, 1)
        ch2 := make(chan int, 1)
        ch3 := ch1

        fmt.Println(ch1 == ch2) //false
        fmt.Println(ch1 == ch3) //true

2,slice这种引用类型的比较

slice类型不可比较,只能与零值nil做比较。

    a := []string{}
    b := []string{}
    fmt.Println(a == b)  //invalid operation: a == b (slice can only be compared to nil)

关于slice类型不可比较的原因,后面会专门写文章做讨论。

3, map类型的比较

map类型和slice一样,不能比较,只能与nil做比较。

四,interface{}类型变量的比较

接口类型的变量,包含该接口变量存储的值和值的类型两部分组成,分别称为接口的动态类型和动态值。只有动态类型和动态值都相同时,两个接口变量才相同:

type Person interface {
    getName() string
}

type Student struct {
    Name string
}

type Teacher struct {
    Name string
}

func (s Student) getName() string {
    return s.Name
}

func (t Teacher) getName() string {
    return t.Name
}

func compare(s, t Person) bool {
    return s == t
}

func main() {

    s1 := Student{"minping"}
    s2 := Student{"minping"}
    t := Teacher{"minping"}

    fmt.Println(compare(s1, s2)) //true
    fmt.Println(compare(s1, t))  //false,类型不同
}

而且接口的动态类型必须要是可比较的,如果不能比较(比如slice,map),则运行时会报panic。因为编译器在编译时无法获取接口的动态类型,所以编译能通过,但是运行时直接panic:

type Person interface {
    getName() string
}

type Student map[string]string

type Teacher map[string]string

func (s Student) getName() string {
    return s["name"]
}

func (t Teacher) getName() string {
    return t["name"]
}

func compare(s, t Person) bool {
    return s == t
}

func main() {

    s1 := Student{}
    s1["name"] = "minping"
    s2 := Student{}
    s2["name"] = "minping"

    fmt.Println(compare(s1, s2)) //runtime error: comparing uncomparable type main.Student

}

五,函数类型的比较

golang的func作为一等公民,也是一种类型,而且不可比较

f := func(int) int { return 1 }
g := func(int) int { return 2 }
f == g

六,slice和map的特殊比较

上面说过,map和slice是不可比较类型,但是有没有特殊的方法来对slice和map做比较呢,有

1,[]byte类型的变量,使用工具包byte提供的函数就可以做比较

s1 := []byte{'f', 'o', 'o'}
s2 := []byte{'f', 'o', 'o'}
fmt.Println(bytes.Equal(s1, s2)) // true
s2 = []byte{'b', 'a', 'r'}
fmt.Println(bytes.Equal(s1, s2)) // false
s2 = []byte{'f', 'O', 'O'}
fmt.Println(bytes.EqualFold(s1, s2)) // true
s1 = []byte("źdźbło")
s2 = []byte("źdŹbŁO")
fmt.Println(bytes.EqualFold(s1, s2)) // true
s1 = []byte{}
s2 = nil
fmt.Println(bytes.Equal(s1, s2)) // true

2,使用反射

reflect.DeepEqual函数可以用来比较两个任意类型的变量

func DeepEqual(x, y interface{})

对map类型做比较:

m1 := map[string]int{"foo": 1, "bar": 2}
m2 := map[string]int{"foo": 1, "bar": 2}
// fmt.Println(m1 == m2) // map can only be compared to nil
fmt.Println(reflect.DeepEqual(m1, m2)) // true
m2 = map[string]int{"foo": 1, "bar": 3}
fmt.Println(reflect.DeepEqual(m1, m2)) // false
m3 := map[string]interface{}{"foo": [2]int{1,2}}
m4 := map[string]interface{}{"foo": [2]int{1,2}}
fmt.Println(reflect.DeepEqual(m3, m4)) // true
var m5 map[float64]string
fmt.Println(reflect.DeepEqual(m5, nil)) // false
fmt.Println(m5 == nil) // true

对slice类型做比较:

s := []string{"foo"}
fmt.Println(reflect.DeepEqual(s, []string{"foo"})) // true
fmt.Println(reflect.DeepEqual(s, []string{"bar"})) // false
s = nil
fmt.Println(reflect.DeepEqual(s, []string{})) // false
s = []string{}
fmt.Println(reflect.DeepEqual(s, []string{})) // true

对struct类型做比较:

type T struct {
    name string
    Age  int
}
func main() {
    t := T{"foo", 10}
    fmt.Println(reflect.DeepEqual(t, T{"bar", 20})) // false
    fmt.Println(reflect.DeepEqual(t, T{"bar", 10})) // false
    fmt.Println(reflect.DeepEqual(t, T{"foo", 10})) // true
}

可以发现,只要变量的类型和值相同的话,reflect.DeepEqual比较的结果就为true

2,使用google的cmp包

直接看用例:

import (
    "fmt"
    "github.com/google/go-cmp/cmp"
)
type T struct {
    Name string
    Age  int
    City string
}
func main() {
    x := T{"Michał", 99, "London"}
    y := T{"Adam", 88, "London"}
    if diff := cmp.Diff(x, y); diff != "" {
        fmt.Println(diff)
    }
}

结果为:

 main.T{
-       Name: "Michał",
+       Name: "Adam",
-       Age:  99,
+       Age:  88,
        City: "London",
  }

五,总结

  • 1,复合类型,只有每个元素(成员)可比较,而且类型和值都相等时,两个复合元素才相等
  • 2,slice,map不可比较,但是可以用reflect或者cmp包来比较
  • 3,func作为golnag的一等公民,也是一个类型,也不能比较。
  • 4,引用类型的比较是看指向的是不是同一个变量
  • 5,类型再定义(type A string)不可比较,是两种不同的类型
  • 6,类型别名(type A = string)可比较,是同一种类型。

六,拓展知识

1, golang的类型再定义和类型别名
2,golang的slice和map为什么不可以比较

七,参考

1,https://medium.com/golangspec/equality-in-golang-ff44da79b7f1

2,https://studygolang.com/articles/19144
3,https://juejin.im/post/5d5ff27d518825637965f3f3

你可能感兴趣的:(这可能是最全的golang的"=="比较规则了吧)