Golang interface底层数据结构

golang 中interface是必须要掌握的内容的,其底层是eface和iface,了解这两种数据结构才能更好的了解和使用interface,基于go v1.13,structgo接口有两种定义:efaceiface

    type eface struct {
        _type *_type
        data  unsafe.Pointer
    }

    type iface struct {
        tab  *itab
        data unsafe.Pointer
    }

eface

eface表示没有任何方法的接口:interface{}.

eface两个字段:_typedatadata实际上是一个指向真实数据的指针。_type定义如下:

    type _type struct {
        size       uintptr
        ptrdata    uintptr
        hash       uint32
        tflag      tflag
        align      uint8
        fieldalign uint8
        kind       uint8
        alg        *typeAlg
        gcdata     *btye
        str        nameOff
        ptrToThis  typeOff
    }

_type是接口内部存储的具体数据的真实类型。

iface

iface两个字段:tabdatadata是指向真实数据的指针。itab定义如下:

    type itab struct {
        inter *interfacetype
        _type *_type
        hash  uint32
        _     [4]byte
        fun   [1]uintptr
    }

    type interfacetype struct {
        typ     _type
        pkgpath name
        mhdr    []imethod
    }

interfacetype描述接口自己的类型。是具体数据的_type类型,同_typein efacefun是指向方法集的指针。它用于动态调度。

reflect.TypeOf

Go func 传递的所有参数都是值。当参数传递给reflect.TypeOf()时,它将被转换为interface{}类型。如果传递的值是接口类型,具体的数据类型将存储在eface _type字段中。然后,将efacestruct 转换emptyInterface为 have typand word

    func TypeOf(i interface{}) Type {
        eface := *(emptyInterface)(unsafe.Poiter(&i))
        return toType(eface.typ)
    }

    type emptyInterface struct {
        typ  *rtype
        word unsafe.Pointer
    }

reflect.ValueOf

reflect.Value是一个结构体,定义如下:

    // Value is the reflection interface to a Go value.
    //
    // Not all methods apply to all kinds of values. Restrictions,
    // if any, are noted in the documentation for each method.
    // Use the Kind method to find out the kind of value before
    // calling kind-specific methods. Calling a method
    // inappropriate to the kind of type causes a run time panic.
    //
    // The zero Value represents no value.
    // Its IsValid method returns false, its Kind method returns Invalid,
    // its String method returns "<invalid Value>", and all other methods panic.
    // Most functions and methods never return an invalid value.
    // If one does, its documentation states the conditions explicitly.
    //
    // A Value can be used concurrently by multiple goroutines provided that
    // the underlying Go value can be used concurrently for the equivalent
    // direct operations.
    //
    // To compare two Values, compare the results of the Interface method.
    // Using == on two Values does not compare the underlying values
    // they represent.
    type Value struct {
        // typ holds the type of the value represented by a Value.
        typ *rtype

        // Pointer-valued data or, if flagIndir is set, pointer to data.
        // Valid when either flagIndir is set or typ.pointers() is true.
        ptr unsafe.Pointer

        // flag holds metadata about the value.
        // The lowest bits are flag bits:
        //  - flagStickyRO: obtained via unexported not embedded field, so read-only
        //  - flagEmbedRO: obtained via unexported embedded field, so read-only
        //  - flagIndir: val holds a pointer to the data
        //  - flagAddr: v.CanAddr is true (implies flagIndir)
        // Value cannot represent method values.
        // The next five bits give the Kind of the value.
        // This repeats typ.Kind() except for method values.
        // The remaining 23+ bits give a method number for method values.
        // If flag.kind() != Func, code can assume that flagMethod is unset.
        // If ifaceIndir(typ), code can assume that flagIndir is set.
        flag

        // A method value represents a curried method invocation
        // like r.Read for some receiver r. The typ+val+flag bits describe
        // the receiver r, but the flag's Kind bits say Func (methods are
        // functions), and the top bits of the flag give the method number
        // in r's type's method table.
    }

    func ValueOf(i interface{}) Value {
        if i == nil {
            return Value{}
        }

        escapes(i)

        return unpackEface(i)
    }

    func unpackEface(i interface{}) Value {
        e := (*emptyInterface)(unsafe.Pointer(&i))
        t := e.typ
        if t == nil {
            return Value{}
        }
        f := flag(t.Kind())
        if ifaceIndir(t) {
            f |= flagIndir
        }
        return Value{t, e.word, f}
    }
Golang 字符串
golang切片和数组区别
标签:

发表我的评论

电子邮件地址不会被公开。 必填项已用*标注

36 + 10 =

ajax-loader