Go | struct 的比较

1. struct 能不能进行比较？

• 不同类型的 struct 之间不能进行比较，编译期就会报错（GoLand 会直接提示）
• 同类型的 struct 也分为两种情况，
  • struct 的所有成员都是可以比较的，则该 strcut 的不同实例可以比较
  • struct 中含有不可比较的成员（如 Slice），则该 struct 不可以比较

1.1. 同类型 struct 比较

import "fmt"

type A struct {
	age  int
	name string
}

func StructCompare1() {
	aObj1 := A{
		age:  13,
		name: "张三",
	}
	aObj2 := A{
		age:  13,
		name: "张三",
	}
	fmt.Println(aObj1 == aObj2) // true

	aObj3 := &A{
		age:  13,
		name: "张三",
	}
	aObj4 := &A{
		age:  13,
		name: "张三",
	}

	fmt.Println(aObj3 == aObj4) // false

	var aObj5 A
	fmt.Println(aObj5) //{0 } ，未明确初始化时，struct 实例的成员取各自的零值
	//fmt.Println( aObj5 == nil)  // 报错，无法将 nil 转换为类型 A

	var aObj6 *A
	fmt.Println(aObj6)        // <nil> ，指针类型数据的零值为 nil
	fmt.Println(aObj6 == nil) //  true，指针类型的数据可以和 nil 比较
}

1.2. struct 包含不可比较的成员

1.3. 不同类型 struct 不能比较

2. 扩展：不可比较的类型

2.1. Slice

go 语言中规定 slice 之间不能比较，因此我们不能使用==操作符来判断两个slice是否含有全部相等元素。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PBbMGQ9Y-1620873981270)(pics/20210513094853152_1085247374.png)]

但标准库提供了高度优化的 bytes.Equal 函数来判断两个字节型 slice 是否相等( []byte ):

func SliceCompare() {
	slice1 := []byte{1, 2, 3}
	slice2 := []byte{1, 2, 3}
	fmt.Println(bytes.Equal(slice1, slice2)) // true
}

对于其他类型的 slice，我们必须自己展开每个元素进行比较，如：

func equal(x, y []string) bool {
    if len(x) != len(y) {
        return false
    }
    for i := range x {
        if x[i] != y[i] {
            return false
        }
    }
    return true 
}

为何slice不直接支持比较运算符呢?

• slice 的元素是间接引用的，一个 slice 甚至可以包含自身。虽然有很多办法处理这种情形，但是没有一个是简单有效的。
• 由于 slice 的元素是间接引用的，一个固定的 slice 值(指slice本身的值，不是元素的值)在不同的时刻可能包含不同的元素，因为底层数组的元素可能会被修改.

slice 唯一合法的比较操作是和 nil 比较，一个 slice 的零值为 nil 。

一个 nil 值的 slice 并没有底层数组。一个 nil 值的 slice 的长度和容量都是0，但是也有非 nil 值的 slice 的长度和容量也是 0 的，例如 []int{} 或 make([]int, 3)[3:] 。

与任意类型的 nil 值一样，我们可以用 []int(nil) 类型转换表达式来生成一个对应类型 slice 的 nil 值。

2.2. Map

和 slice 一样，map 之间也不能进行相等比较; 唯一的例外是和 nil 进行比较。

要判断两个 map 是否包含相同的 key 和 value，我们必须通过一个循环实现:

func equal(x, y map[string]int) bool {
    if len(x) != len(y) {
        return false
    }
    for k, xv := range x {
        if yv, ok := y[k]; !ok || yv != xv {
            return false
        }
    }
    return true 
}

上述例子中在判断 xv 和 yv 是否相等时，先通过 ok 判断了 yv 是否存在，这一步判断是必须的，如果简单地用 xv != y[k] 则可能会出现错误的结果，比如下面的例子：

equal(map[string]int{"A": 0}, map[string]int{"B": 42})

在比较上面这两个 map 时，如果没有对 ok 进行判断，那么从后面的 map 中取 y["A"] 时，由于后面的 map 中不存在 A 这个键，所有会拿到值类型的零值，即0，此时 x["A"] 的值恰好也是 0 ，这样就会出现错误的结果。

2.3. 函数类型的变量

在 go 语言中，函数可以作为变量的类型，如 var f func(int) int，该语句声明了一个变量 f ，其类型为接收 int 类型参数且返回值为 int 的函数。

// squares返回一个匿名函数。
// 该匿名函数每次被调用时都会返回下一个数的平方。 
func squares() func() int {
    var x int
    return func() int {
        x++
        return x * x 
    }
}

func main() {
    f := squares()
    fmt.Println(f()) // "1"
    fmt.Println(f()) // "4"
    fmt.Println(f()) // "9"
    fmt.Println(f()) // "16"
}

在上述示例中，将函数赋值给变量 f 时，函数内部的成员变量 x 的生命周期会受变量 f 的生命周期影响，所以输出结果依次是 1、4、9、16。也就是说，函数类型的值不仅仅是一串代码，还记录了状态。在 squares 中定义的匿名内部函数可以访问和更新 squares 中的局部变量，这意味着匿名函数和 squares 中，存在变量引用。这就是函数值属于引用类型和函数值不可比较的原因。

在上上述示例中，如果不将函数赋值给变量，而是直接调用，其写法和运行结果如下

fmt.Println(Squares()())    //1
fmt.Println(Squares()())    //1

---