XuLaLa.Tech

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

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

eface

eface表示没有任何方法的接口：interface{}.有eface两个字段：_type和data。data实际上是一个指向真实数据的指针。_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两个字段：tab和data。data是指向真实数据的指针。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 eface。fun是指向方法集的指针。它用于动态调度。

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