golang中如何比较struct,slice,map是否相等以及几种对比方法的区别

一、前言

structmapslice==，reflect.DeepEqual()，cmp.Equal()

==

二、== 的对比方式

1、golang的四大类型

golang

基本类型：整型（
int/uint/int8/uint8/int16/uint16/int32/uint32/int64/uint64/byte/rune等）、浮点数（
float32/float64）、复数类型（
complex64/complex128）、字符串（
string）。
复合类型（又叫聚合类型）：数组和结构体类型。
引用类型：切片（slice）、map、channel、指针。
接口类型：如error ：类型一致且是基本类型，值相等的时候，才能==，非基本类型会panic panic: runtime error: comparing uncomparable type []int

2、== 适用的类型

==string,intstruct

int1:=10
int2:=10
str1:="11"
str2:="11"
if int1 == int2{}
if str1 == str2{}

intstring

3、slice和map使用 ==

首先golang里面有种说法：

切片之间不允许比较。切片只能与nil值比较。
map之间不允许比较。map只能与nil值比较。

那么我们分别测试下发现：

（1）map比较会报错：map can only be compared to nil
（2）切片报错：the operator == is not defined on []int64
    slice can only be compared to nil

（1）那么两个nil是否可以==比较呢

答案是不能：invalid operation: nil == nil (operator == not defined on nil)

（2）slice,map使用==的场景

就像上面说的，slice和map只能和nil使用==，他们各自之间是不可以的。

s1 := []int64{1, 2}
if s1 == nil {} //编辑器不会提示报错

（3）为什么slice和map不可以

slicemaplencap==reflect.DeepEqual()

4、channel使用 ==

channelchannel==

ch1 := make(chan int, 1)
ch2 := ch1
if cha2 == cha1{fmt.Println("true")}

5、struct结构体使用==

（1）首先要明确几点：

1）结构体的定义只是一种内存布局的描述，只有当结构体实例化时，才会真正地分配内存。
实例化就是根据结构体定义的格式创建一份与格式一致的内存区域，结构体实例与实例间的
内存是完全独立的
2）对结构体进行&取地址操作时，视为对该类型进行一次 new 的实例化操作
因此：go中的结构体: v = Struct {}, v = &Struct{} 这个两种写法是等价的

结构体这里比较复杂一些。我们可以先下结论：

1、简单结构的结构体，里面都是值类型或者指针的话，是可以使用 ==的
2、结构体中含有slice或者map，都是不可以用==

（2）简单结构体的==

type Value struct {
    Name   string
    Gender string
    }
 
    func main() {
        v1 := Value{Name: "test", Gender: "男"}
        v2 := Value{Name: "test", Gender: "男"}
        if v1 == v2 {
            fmt.Println("true")
            return
        }
    }

（3）带指针的结构体==

    首先要明确，指针类型指向的地址不一样，肯定是没办法比较的，如果地址一样，那么也可以用==
    type Value struct {
    Name   string
    Gender *string
    }
 
    func main() {
         Gender ：=new(string) //下面赋值用的同一个变量，地址相同
        v1 := Value{Name: "test", Gender: Gender}
        v2 := Value{Name: "test", Gender: Gender}
        if v1 == v2 {
            fmt.Println("true")
            return
        }
    }

（4）强制转换类型的==

type StructA struct {
    Name string
    }
 
    type StructB struct {
        Name string
    }
 
    func main() {
        s1 := StructA{Name: "test1"}
        s2 := StructB{Name: "test1"}
        if s1 == StructA(s2) {
            fmt.Println("true")
            return
        }    
   }

slicemap

三、reflect.DeepEqual() 和cmp.Equal()

1、reflect.DeepEqual()

reflectgoslice,map，struct，function

（1）对比规则

  	相同类型的值是深度相等的，不同类型的值永远不会深度相等。
    当数组值（array）的对应元素深度相等时，数组值是深度相等的。
    当结构体（struct）值如果其对应的字段（包括导出和未导出的字段）都是深度相等的，则该值是深度相等的。
    当函数（func）值如果都是零，则是深度相等；否则就不是深度相等。
    当接口（interface）值如果持有深度相等的具体值，则深度相等。
    当切片（slice）序号相同，如果值,指针都相等，那么就是深度相等的
    当哈希表（map）相同的key，如果值，指针都相等，那么就是深度相等的。

（2）对比实例

通过规则可以知道，reflect.DeepEqual是可以比较struct的，同时也可以用来比较slice和map。
     func main() {
        s1 := StructA{Name: "test", Hobby: []string{"唱", "跳"}}
        s2 := StructA{Name: "test", Hobby: []string{"唱", "跳"}}
        if reflect.DeepEqual(s1, s2) {
            fmt.Println("struct true")
        }
        mp1 := map[int]int{1: 10, 2: 20}
	mp2 := map[int]int{1: 10, 2: 20}
         if ok := reflect.DeepEqual(mp1, mp2);ok {
		fmt.Println("mp1 == mp2!")
	    } else {
		fmt.Println("mp1 != mp2!")
	    }
    }
  

2、cmp.Equal()

go-cmpGoogle

reflect.DeepEqual

（1）对比规则：

1.在经过路径过滤，值过滤和类型过滤之后，会生一些忽略、转换、比较选项，如果选项中存在忽略，
则忽略比较，如果转换器和比较器的数据大于1，则会panic（因为比较操作不明确）。如果选项中
存在转换器，则调用转换器转换当前值，再递归调用转换器输出类型的Equal。如果包含一个比较器。
则比较使用比较器比较当前值。否则进入下一比较阶段。

2.如果比较值有一个(T) Equal(T) bool 或者 (T) Equal(I) bool，那么，即使x与y是nil，
也会调用x.Equal(y)做为结果。如果不存在这样的方法，则进入下一阶段。

3.在最后阶段，Equal方法尝试比较x与y的基本类型。使用go语言的 == 比较基本类型
（bool, intX, float32,float64, complex32,complex64, string, chan）。

4.在比较struct时，将递归的比较struct的字段。如果结构体包含未导出的字段，函数会panic。
可以通过指定cmpopts.IgnoreUnexported来忽略未导出的字段，也可以使用
cmp.AllowUnexported来指定比较未导出的字段。

（2）代码

// 传入要对比的结构即可
func Equal(x, y interface{}, opts ...Option) bool {
	s := newState(opts)
	s.compareAny(rootStep(x, y))
	return s.result.Equal()
}

//获取diff差异
func Diff(x, y interface{}, opts ...Option) string {
}

3、cmp和DeepEqual的区别？

安全：cmp.Equal()函数不会比较未导出字段（即字段名首字母小写的字段）。遇到未导出字段，
cmp.Equal()直接panic，reflect.DeepEqual()会比较未导出的字段。

强大：cmp.Equal()函数提供丰富的函数参数，让我们可以实现：忽略部分字段，比较零值，
转换某些值，允许误差等。

共同点：两种比较类型，都会比较：对象类型，值，指针地址等。切片会按照索引比较值，
map是按照key相等比较值

四、其他对比方式

1、testify库的 assert.Equal()

assert.Equal()

（1）[]byte类型就使用bytes.Equal()
（2）非[]byte类型，使用reflect.DeepEqual()
（3）不相等则获取diff

2、bytes.Equal()

byte slicebytes.Compare

reflect.DeepEqual()sliceuint8[]bytebytes

case Slice:
        // Special case for []byte, which is common.
        if v1.Type().Elem().Kind() == Uint8 {
         return bytealg.Equal(v1.Bytes(), v2.Bytes())
        }
        //转化为string之间的对比
        func Equal(a, b []byte) bool {
         return string(a) == string(b)
        }

五、效率对比及总结

1、效率对比

1、简单类型的==对比速度最快
2、复杂类型，自己知道结构之后写的自定义对比速度次之
3、复杂结构且不确定结构的，使用cmp.Equal()或者reflect.DeepEqual()都可以，就是效率低点
4、assert.Equal()底层使用的就是reflect.DeepEqual()

2、总结

cmp

end