深入理解 Go Comparable Type

sorcererxw•2021年9月23日

介绍¶

在 Go reflect 包里面对 Type 有一个 Comparable 的定义：

package reflect

type Type interface {
	// Comparable reports whether values of this type are comparable.
	Comparable() bool
}

正如字面意思，Comparable 表示一个类型是否可以直接使用运算符比较。Go spec 罗列了所有可比较的类型，其中将可比较性划分为两个维度（如果不符合要求，会直接在编译期报错）：

Comparable：可以使用 == 和 != 比较，非黑即白
Ordered：可以使用 > >= < <= 做大小比较，有明确的大小概念

我简单整理了一下所有 Go 内置类型的约定：

Type	Comparable	Ordered	Description
Boolean	✅	❌
Integer	✅	✅
Float	✅	✅
Complex	✅	❌	分别比较实数和虚数，同时相等则两个复数相等。如果需要比较大小，需要开发者分别比较实数和虚数。
String	✅	✅	基于字节逐个比较。
Pointer	✅	❌	如果两个指针指向同一个对象或者都为 nil，则两者相等。
Channel	✅	❌	类似 Pointer，两个 Channel 变量只有都为 nil，或者指向同一个 Channel 的时候才相等。
Interface	✅	❌	两个 interface 的 Type 和 Value 值同时相等时，两者才相等。
Struct	⚠️	❌	仅当 Struct 内所有成员都是 Comparable，这个 Struct 才是 Comparable 的。如果两个 struct 类型相同，且所有非空成员变量都相等，则两者相等。
Array	⚠️	❌	仅当成员为 Comparable，Array 才是 Comparable 的。如果两个 Array 中的每一个元素一一相等时，则两个 Array 相等。
Map	❌	❌
Slice	❌	❌
Func	❌	❌

从上面可以看到，Go 当中绝大多数类型都是可以使用运算符相互比较的，唯独不包含 Slice，Map 和 Func，也有容器类型 Struct、Array 本身的 Comparable 取决于成员的类型。

内部实现¶

知道了语法约定，我们可以看一下 reflect 具体是怎么判断一个变量的 Comparable 属性：

type rtype struct {
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	equal func(unsafe.Pointer, unsafe.Pointer) bool
}

func (t *rtype) Comparable() bool {
	return t.equal != nil
}

很简单，其实就是为每一个类型配备了一个 equal 比较函数，如果有这个函数则是 comparable。

上面的 rtype 结构就包含在所有类型的内存头部：

// emptyInterface is the header for an interface{} value.
type emptyInterface struct {
	typ  *rtype
	word unsafe.Pointer
}

所以如果希望知道某一个类型的 equal 需要翻阅对应类型源码。通过编译 SSA 可以找到对应类型的比较函数。

比如在 go/src/runtime/alg.go 下可以看到 interface 的 equal 函数的具体实现：

func efaceeq(t *_type, x, y unsafe.Pointer) bool {
	if t == nil {
		return true
	}
	eq := t.equal
	if eq == nil {
		panic(errorString("comparing uncomparable type " + t.string()))
	}
	if isDirectIface(t) { // t.kind == kindDirectIface
		// Direct interface types are ptr, chan, map, func, and single-element structs/arrays thereof.
		// Maps and funcs are not comparable, so they can't reach here.
		// Ptrs, chans, and single-element items can be compared directly using ==.
		return x == y
	}
	return eq(x, y)
}

现实中的陷阱与应用¶

在知道上面的设定之后，可以理解很多我们在开发当中碰到的错误。

errors.Is¶

我们常常在模块内定义错误时，会定义出如下类型：

type CustomError struct {
	Metadata map[string]string
	Message string
}

func (c CustomError) Error() string {
		return c.Message
}

var (
	ErrorA = CustomError{Message:"A", Matadata: map[string]string{"Reason":""}}
	ErrorB = CustomError{Message:"B"}
)

func DoSomething() error {
	return ErrorA
}

而我们在外部接收到错误之后常常会使用 errors.Is 来判断错误类型：

err:=DoSomething()
if errors.Is(err, ErrorA) {
	// handle err
}

但是会发现上面这个判断无论如何都是 false。研究一下 errors.Is 的源码：

func Is(err, target error) bool {
	if target == nil {
		return err == target
	}

	isComparable := reflect.TypeOf(target).Comparable()
	for {
		if isComparable && err == target {
			return true
		}
		if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
			return true
		}
		if err = errors.Unwrap(err); err == nil {
			return false
		}
	}
}

可以看到这是一个在 error tree 上递归的流程，真值的终结条件是 err==target ，但是前提是 target 本身得是 comparable 的。

A comparison of two interface values with identical dynamic types causes a run-time panic if values of that type are not comparable.

如上描述，如果不加上这一段约束，会引发 panic。

所以如果我们把一个 map 放入了 error struct，就导致这个 error 变为 incomparable，永远无法成功比较。

解决方案也很简单，就是将 Error 定义指针类型：

var (
	ErrorA = &CustomError{Message:"A", Matadata: map[string]string{"Reason":""}}
	ErrorB = &CustomError{Message:"B"}
)

指针类型比较只需要是否检查是否指向同一个对象，这样就能顺利比较了。

(*Type)(nil) ≠ nil ¶

这是 Go FAQ 的其中一条：

func returnsError() error {
	var p *MyError = nil
	if bad() {
		p = ErrBad
	}
	return p // Will always return a non-nil error.
}

上面返回的 p 永远不会与 nil 相等。

这是为什么呢，因为 error 是一个 interface，从上面可以知道，interface 之间比较需要保证两者的 Type 和 Value 两两相等：

语言内的 nil 可以理解为一个 Type 和 Value 均为空的 interface
代码里面返回的 p 虽然 Value 为空，但是 Type 是 *MyError

所以 p!=nil 。

正确的代码应该是这样的：

func returnsError() error {
	if bad() {
		return ErrBad
	}
	return nil
}

这个问题不仅仅是抛出错误的时候会出现，任何返回 interface 的场景都需要注意。

Context Value Key¶

Go 的 Context 可以存取一些全局变量，其存储方式是一个树状结构，每一次取值的时候就会从当前节点一路遍历到根节点，查找是否有对应的 Key：

func (c *valueCtx) Value(key interface{}) interface{} {
	if c.key == key {
		return c.val
	}
	return c.Context.Value(key)
}

那么就可能会出现因为子节点的 Key 与其中一个父节点的 Key 相同，导致 Value 被错误地覆盖。比如：

ctx = Context.Background()
ctx = context.WithValue(ctx, "key", "123")
ctx = context.WithValue(ctx, "key", "456")
ctx.Value("key") // 456

因为 Context 是全链路透传的，谁都没法保证一个 Key 是否会被其中某一层覆盖。这个问题本质上是：当Key 的类型为 Integer/Float/String/Complex 时，"伪造"一个值相同的 Key 太容易了。那么我们可以运用 Go Comparable 的特性，选择无法被"伪造"的类型作为 Key。推荐两种比较优雅的方式：

指针类型
```
var key = byte(0)

ctx = context.WithValue(ctx, &key, "123")
ctx.Value(&key)
```
这样一来，除了包内函数，没有其他代码还能构造出相同的指针了。
Struct 类型
从上文可以知道，strcut 只要类型相同，内部的值相等，就能直接使用 == 判断相等，那么我们可以直接使用 struct 作为 Key。
```
type key struct {}

ctx = context.WithValue(ctx, key{}, "123")
ctx.Value(key{})
```
同样的，我们把 struct 定义为私有类似，包外也无法构造出相同的 key。
我们知道空 struct 是不占用内存的，这么做相比指针类型的 Key，可以减少内存开销。