深入理解 Go Comparable Type | SORCERERXW
在 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:可以使用 = ==? 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) } 在知道上面的设定之后,可以理解很多我们在开发当中碰到的错误。 我们常常在模块内定义错误时,会定义出如下类型: 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 的。 如上描述,如果不加上这一段约束,会引发 panic。 所以如果我们把一个 map 放入了 error struct,就导致这个 error 变为 incomparable,永远无法成功比较。 解决方案也很简单,就是将 Error 定义指针类型: var ( ErrorA = &CustomError{Message:"A", Matadata: map[string]string{"Reason":""}} ErrorB = &CustomError{Message:"B"} ) 指针类型比较只需要是否检查是否指向同一个对象,这样就能顺利比较了。 这是 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 的场景都需要注意。 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,可以减少内存开销。
· sorcererxw.com · Jul 23, 2022