go - 对接口(interface)进行类型断言，内部发生了什么

Question

我很好奇当 Go 以另一个接口(interface)作为其目标执行类型断言时，内部会发生什么。仅作为示例，请考虑来自 Dave Cheney's blog 的示例:

type temporary interface {
    Temporary() bool
}

// IsTemporary returns true if err is temporary.
func IsTemporary(err error) bool {
        te, ok := err.(temporary)
        return ok && te.Temporary()
}

我预计这里会发生相当多的运行时开销，因为它必须检查 err 的类型并确定它是否具有所有方法。是这样吗，还是在下面发生了一些聪明的魔法？

Answer 1

您描述的期望有效且有效。运行时必须检查 method set 是否动态类型的是您要断言的接口(interface)类型的超集。

但不要害怕。执行此操作已经过大量优化(这是您的“智能魔法”)。

首先，函数类型在内部由结构描述，其中方法签名(参数和结果类型)由称为签名 ID 的单个整数值表示。如果 2 个函数具有相同的签名，则它们具有相同的签名 ID。因此，要比较 2 个函数(判断 2 个方法是否相同)，运行时只需比较名称(字符串比较)和签名 ID(整数比较)。

接下来，动态类型T 是否实现接口(interface)I 只被检查/计算一次，结果被缓存。所以这个检查虽然有一些工作，但不会执行多次，只会执行一次，每当需要进行同类型检查(同类型断言)时，就会查找并使用缓存的结果。

因此，接口(interface)类型的类型断言最终归结为:(1) 计算哈希值(一些按位运算)，(2) 从映射中查找值，以及 (3) 构造结果接口(interface)值。

有关接口(interface)表示的介绍，请阅读 Russ Cox: Go Data Structures: Interfaces .

这是一篇包含上述所有详细信息的文章:How interfaces work in Go

例如，描述函数的相关部分是:

type _func struct {
    name      string  
    methodSig uint // two methods with the same signature have
                   // the same signature id. Receiver parameter
                   // doesn't contribute to this signature.
    funcSig   uint // receiver parameter accounts to this signature.

    // other information ...
}

类型断言接口(interface)类型:

这是将接口(interface)值断言到接口(interface)类型的内部函数:

// To call this function, compilers must assure 
// 1. itype is an interface type.
// 2. outI is nil or stores the address of a value of itype.
// 3. outOk is nil or stores the address of a bool value.
func assertI2I (ivalue _interface, itype *_type,
        outI *_interface, outOk *bool) {
    // dynamic value is untype nil.
    if ivalue.dynamicTypeInfo == nil {
        // if ok is not present, panic.
        if outOk == nil {
            panic("interface is nil, not " + itype.name)
        }

        *outOk = false
        if outI == nil {
            *outI = _interface {
                dynamicValue:    nil,
                dynamicTypeInfo: nil,
            }
        }

        return
    }

    // check whether or not the dynamic type implements itype
    var impl = getImpl(itype, ivalue.dynamicTypeInfo.dtype)

    // assersion fails.
    if impl == nil {
        // if ok is not present, panic.
        if outOk == nil {
            panic("interface is " +
                ivalue.dynamicTypeInfo.dtype.name +
                ", not " + itype.name)
        }

        // return (zero value, false)
        *outOk = false
        if outI != nil {
            *outI = _interface {
                dynamicValue:    nil,
                dynamicTypeInfo: nil,
            }
        }

        return
    }

    // assersion succeeds.

    if outI == nil {
        *outOk = true
    }
    if outI != nil {
        *outI = _interface {
            dynamicValue:    ivalue.dynamicValue,
            dynamicTypeInfo: impl,
        }
    }
}

这是从接口(interface)类型和非接口(interface)类型获取 _implementation 值的函数:

// global table
var cachedImpls = map[uint64]*_implementation{}

// itype must be an interface type and
// dtype must be a non-interface type.
// Return nil if dtype doesn't implement itype.
// Must not return nil if dtype implements itype.
func getImpl (itype *_type, dtype *_type) *_implementation {
    var key = uint64(itype.id) << 32 | uint64(dtype.id)
    var impl = cachedImpls[key]
    if impl == nil {
        // for each (dtype, itype) pair, the implementation
        // method table is only calculated most once at
        // run time. The calculation result will be cached.

        var numMethods = len(itype.methods)
        var methods = make([]*_func, numMethods)

        // find every implemented methods.
        // The methods of itype and dtype are both sorted
        // by methodSig and name.
        var n = 0
        var i = 0
        for _, im := range itype.methods {
            for i < len(dtype.methods) {
                tm := dtype.methods[i]
                i++

                // Here, for simplicity, assume
                // all methods are exported.

                if tm.methodSig < im.methodSig {
                    continue
                }
                if tm.methodSig > im.methodSig {
                    // im method is not implemented
                    return nil
                }
                if tm.name < im.name {
                    continue
                }
                if tm.name > im.name {
                    // im method is not implemented
                    return nil
                }

                methods[n] = tm
                n++
                break
            }
        }

        // dtype doesn't implement all methods of itype
        if n < numMethods {
            return nil
        }

        // dtype implements itype.
        // create and cache the implementation.
        impl = &_implementation{
            dtype: dtype, 
            itype: itype, 
            methods: methods,
        }
        cachedImpls[key] = impl
    }

    return impl
}