Go结构体比较

有名结构体对象的比较，只有同结构体类型才能比较：

type A struct {
	age int
}

type B struct {
	age int
}

func main() {
	a := A{age: 10}
	b := A{age: 10}
	c := B{age: 10}

    // 可以比较，a 与 b 同一结构体类型
	fmt.Println(a == b)
    // 不可比较，编译会报错，a 与 c 不是同一结构体类型
	fmt.Println(a == c)
}

匿名结构体对象的比较，如果匿名结构体的属性相同、顺序相同、数量相同，且属性类型可比较，结构体对象才能比较：

package main

import "fmt"

func main() {
	var a = struct {
		age  int
		name string
	}{age: 10, name: "andy"}

	var b = struct {
		age  int
		name string
	}{age: 10, name: "andy"}

	var c = struct {
		name string
		age  int
	}{age: 10, name: "andy"}

	var d = struct {
        age    int
		name   string
		gender string
	}{age: 10, name: "andy"}

	var e = struct {
		age     int
		name    string
		habbits []string
	}{age: 10, name: "andy"}

	var f = struct {
		age     int
		name    string
		habbits []string
	}{age: 10, name: "andy"}

    // 可以比较
	fmt.Println(a == b)

    // 不能比较，编译会出错，a 和 c 结构体的属性虽然相同但顺序不同
	fmt.Println(a == c)

    // 不能比较，编译会出错，a 和 d 结构体属性数量不同
	fmt.Println(a == d)

    // 不能比较，编译会出错，slice 不能比较，因此结构体也不能比较
	fmt.Println(e == f)
}

能直接比较的数据类型有：

• 布尔
• 数字
• 字符串
• 接口
• 通道
• 结构体
• 指针

对于含有不可比较类型的结构体，可以使用 reflect.

var e = struct {
    age     int
    name    string
    habbits []string
}{age: 10, name: "andy"}

var f = struct {
    age     int
    name    string
    habbits []string
}{age: 10, name: "andy"}
// true
fmt.Println(reflect.DeepEqual(e,f))

引申来说，slice、map对象是不能比较的：

var s1 = []int{1, 2, 3}
var s2 = []int{1, 2, 3}
// Invalid operation: s1 == s2 (the operator == is not defined on []int)，不能比较，编译会报错
fmt.Println(s1 == s2)
// true
fmt.Println(reflect.DeepEqual(s1, s2))

var m1 = map[int]string{1: "a"}
var m2 = map[int]string{1: "a"}
// Invalid operation: m1 == m2 (the operator == is not defined on map[int]string)，不能比较，编译会报错
fmt.Println(m1 == m2)
// true
fmt.Println(reflect.DeepEqual(m1, m2))