Go 结构体比较，reflect.DeepEqual比较

参考大佬文章~

1.不能使用比较符比较
(1) 切片/数组
(2) Map
(3) 函数
(4) 拥有不同成员或者拥有不能比较的成员的结构体
(5) 拥有不同函数的接口
(6) 不同类型的结构体指针（同类型的结构体对象：new出来的，可以比较，但是由于比较的是地址，所以不准确）
 

2.可以使用比较符比较的特殊类型
(1) 相同类型结构体，且结构体中的成员类型个数完全相同，且不能含有无法比较的成员。
示例：

// 1.可以比较的结构体，因为成员类型个数完全一致，且不存在无法比较的类型
type AA struct {
	a int
}
type AB struct {
	a int
}
func main() {
	aa := AA{a: 5}
	ab := AB{a: 5}
	//可以比较
	if aa == AA(ab) {//这里因为结构体不是同一个，所以强转成同一个
		fmt.Println(true)
	} else {
		fmt.Println(false)
	}
}


// 2.不可以比较的结构体,因为成员个数不一样
type AA struct {
	a int
}

type AB struct {
	a int
	b int
}

func main() {
	aa := AA{a: 5}
	ab := AB{a: 5}
	//报错，不能比较
	if aa == AA(ab) {
		fmt.Println(true)
	} else {
		fmt.Println(false)
	}
}


// 3.用下面两个AA类型结构体不可以比较,因为存在无法比较的类型
type AA struct {
	a int
	b []int //切片不能使用比较符比较
	m map[string]int //字典不能使用比较符比较
}

func main() {
	aa := AA{}
	//报错，不能比较
	if aa == aa {
		fmt.Println(true)
	} else {
		fmt.Println(false)
	}
}

(2) 拥有包含关系的两个接口案例：
示例：

type T1 interface {
	a() []int
}
type T2 interface {
	a() []int
	b() []int
}

func main() {
	var t1 T1
	var t2 T2
	if t1 == t2 { //由于T2对T1是包集（T1中的函数全部为T2的子集，或者T1中没有函数），所以能够比较，结果为true；
		fmt.Println(true)
	} else {
		fmt.Println(false)
	}
}

3. 使用reflect.DeepEqual比较：

上面的代码体现了运算符比较的局限性，那么如果我们想要比较拥有切片等不能比较成员的结构体怎么办呢？（注意：结构体的比较必须为同一个结构体类型，不同类型的需要强制转换）答案是使用反射包的DeepEqual方法！

我们以下面这两个结构体为案例来介绍下：

type AA struct {
    a int
    b []int
}

type AB struct {
    a int
    b []int
}

func main() {
    s1 :=  AA{a:6, b:[]int{2}}
    s2 := AB{a:6, b:[]int{2,3}}
    fmt.Println(reflect.DeepEqual(a, AA(b)))
}

虽然结构体中的第一个成员都是6，但是对象s1、s2两个结构体中的切片长度不一致，所以这里返回false.

另外注意：
结构体中的成员类型顺序不一致，会导致强转失败，如下面的两个结构体将不能进行强转：

type AA struct {
	a int
	b []int
}
type AB struct {
	b []int
	a int
}