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




    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 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是指向方法集的指针。它用于动态调度。


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



    // 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.

        // 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{}


        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 字符串


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

36 + 10 =