Golang-Interface底层是怎么实现的?

引言

• 从runtime包分析学习interface底层结构和interface断言的实现、

是nil，但不完全是nil

func InterfaceTest(v interface{}) {
	fmt.Println(v)
	if v == nil {
		fmt.Println("v is nil")
		return
	}
	fmt.Println("v is not nil")
}

func InterfaceTest2(v *int) {
	fmt.Println(v)
	if v == nil {
		fmt.Println("v is nil")
		return
	}
	fmt.Println("v is not nil")
}

func main() {
	var v *int = nil
	InterfaceTest(v)
	fmt.Println("")
	InterfaceTest2(v)
}

运行main方法，查看输出结果发现：InterfaceTest2是符合预期的。从InterfaceTest的输出来看，v是nil，但不完全为nil，经过interface转换之后发生了什么？

<nil>
v is not nil

<nil>
v is nil

interface底层结构

interface判断与预期不一样的根本原因，interface根本不是那么简简单单，而是两个struct。什么？interface不是单纯的值？是struct，还是两个？

根据interface是否包含method，底层实现上有两种struct：eface，iface

• eface表示不包含任何方法的空接口，也称为 empty interface。

  type eface struct {
      _type *_type // 指向类型信息
      data  unsafe.Pointer // 指向值信息
  }
  
  type _type struct {
      size       uintptr // 类型的大小
      ptrdata    uintptr // 所有指针的内存前缀大小
      hash       uint32  // 类型的hash值。此处提前计算好，可以避免在哈希表中计算
      tflag      tflag   // 额外的类型信息标志。此处为类型的 flag 标志，主要用于反射
      align      uint8   // 对应变量与该类型的内存对齐大小。
      fieldalign uint8   // 对应类型的结构体的内存对齐大小。
      kind       uint8   // 类型的枚举值。包含 Go 语言中的所有类型，例如：kindBool、kindInt、kindInt8、kindInt16 等。
      alg        *typeAlg  // algorithm table
      gcdata    *byte    // 存储垃圾收集器的 GC 类型数据
      str       nameOff  // string form
      ptrToThis typeOff  // type for pointer to this type, may be zero
  }

• iface包含一些method的具体实现，存在itab.fun变量里

  type iface struct {
      tab  *itab
      data unsafe.Pointer
  }
  
  type itab struct {
      inter  *interfacetype // 接口的类型信息
      _type  *_type // 具体类型信息，这个type和eface里的type是一个东西
      link   *itab
      bad    int32
      inhash int32      // has this itab been added to hash?
      fun    [1]uintptr // 底层数组，存储接口的方法集的具体实现的地址，其包含一组函数指针，实现了接口方法的动态分派，且每次在接口发生变更时都会更新
  }
  
  type interfacetype struct {
   typ     _type
   pkgpath name
   mhdr    []imethod
  }
  
  type imethod struct {
   name nameOff
   ityp typeOff
  }

类型断言是怎么实现的？

• 断言分为安全和非安全两种

  func myAssert(v interface{}) {
    // 进行变量断言，若不判断容易出现 panic
  	s := v.(string)
  	// 进行安全断言
    s, ok := v.(string)
  }
  
  func myAssert(v interface{}) {
    // 进行 switch 断言
    switch v.(type) {
    case string:
        // do something
    case int:
        // do something
    case float64:
        // do something
    }
  }

  iface和eface对应不同的方法，安全和不安全也对应两种方法。(runtime包iface.go)

  func assertI2I(inter *interfacetype, i iface) (r iface) {
  	tab := i.tab
  	if tab == nil {
  		// explicit conversions require non-nil interface value.
  		panic(&TypeAssertionError{nil, nil, &inter.typ, ""})
  	}
  	if tab.inter == inter {
  		r.tab = tab
  		r.data = i.data
  		return
  	}
  	r.tab = getitab(inter, tab._type, false)
  	r.data = i.data
  	return
  }
  func assertI2I(inter *interfacetype, i iface) (r iface)
  
  func assertE2I2(inter *interfacetype, e eface) (r iface, b bool)
  func assertE2I(inter *interfacetype, e eface) (r iface)

参考

http://legendtkl.com/2017/07/01/golang-interface-implement/

https://mp.weixin.qq.com/s/vNACbdSDxC9S0LOAr7ngLQ