今天学习了一下Go 接口的底层实现。主要是一篇学习笔记的总结，把自己的思考整理一下。如果想更加深入的了解接口的实现，可以看下参考文献中的文章。

1 概述

接口主要是为了实现多态。Go语言并没有像其他语言中，显式指定继承接口。而是只要实现了接口的方法，就算继承了接口。

1.1 分类与数据结构

在Go语言中，按照是否有函数分为iface跟 eface两种。iface 是包含函数的接口。
我们看下这两种接口的定义：
eface:

type eface struct { // 16 bytes
    _type *_type //  Go 语言中类型的运行时表示
    data  unsafe.Pointer  // 指向原始数据的指针
}

iface:

type iface struct { // 16 bytes
    tab  *itab
    data unsafe.Pointer // 指向原始数据的指针
}

从定义我们可以看出，eface 跟 iface都有data 部分，主要的差别在于eface只有_type, 而iface 有itab（里面包含_type）。
下面我们简单列一下itab的结构（其实普通的type 跟interface 进行转换时，主要是构造跟解析itab）。

type itab struct { // 32 bytes
    inter *interfacetype // 接口类型
    _type *_type // 类型
    hash  uint32 // copy of _type.hash. Used for type switches. 类型的hash。在进行type跟接口转换时，通过这个hash进行比对。
    _     [4]byte
    fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter. 方法列表的具体实现
}

每个字段的含义参考代码中的注释。

1.2 指针与接口

接口在定义一组方法时，并没有对实现的接受者做限制，所以接口的接受者
可以使struct ,也可以是pointer。

receiver-pointerOrStruct.png
（图片来自 https://draveness.me/golang/basic/golang-interface.htm）

另外，接受者在初始化的时候，也可以初始化为结构体或者指针。

var d Duck = Cat{}
// or
var d Duck = &Cat{}

这样两个维度的组合，会产生四种场景， 我们看下代码：

package main

type Duck interface {
    Walk()
    Quack()
}

type Cat struct{}

// 场景一 receiver struct , param struct
//func (c Cat) Walk() {
//  fmt.Println("catwalk")
//}
//func (c Cat) Quack() {
//  fmt.Println("meow")
//}
//
//func TestReceiverStruct_ParamStruct(t *testing.T) {
//  var c Duck = Cat{}
//  c.Quack() // pass
//}

//// 场景二 receiver pointer ,  param pointer
//func (c *Cat) Walk() {
//  fmt.Println("catwalk")
//}
//func (c *Cat) Quack() {
//  fmt.Println("meow")
//}
//
//func TestReceiverStruct_ParamStruct(t *testing.T) {
//  var c Duck = &Cat{}
//  c.Quack() // pass
//}

//// 场景三 receiver struct , but param pointer
//func (c Cat) Walk() {
//  fmt.Println("catwalk")
//}
//func (c Cat) Quack() {
//  fmt.Println("meow")
//}
//
//func TestReceiverStruct_ParamPointer(t *testing.T) {
//  var c Duck = &Cat{}
//  c.Quack() // pass
//}

//// 场景四 receiver pointer , but param struct. 编译不通过，这是因为通过结构体，找不到唯一的指针。
//func (c *Cat) Walk() {
//  fmt.Println("catwalk")
//}
//func (c *Cat) Quack() {
//  fmt.Println("meow")
//}
//
//func TestReceiverStruct_ParamPointer(t *testing.T) {
//  var c Duck = Cat{} // 编译报错
//  c.Quack() // pass
//}

注意： 在编译的时候，可以每次只放开一个场景的代码

我们看到只有第四种（接受者是指针，而初始化为结构体）是编译报错的。
这是因为编译器底层并没有帮助生成一个接受者为结构体的方法。
而场景三（接受者是结构体，初始化为指针）之所以可以，是因为如果接受者是结构体，编译器会隐含的生成一个接受者为指针的对应的方法。

2 类型转换

2.1 具体类型转成interface （协变）

主要流程就是先初始化具体的类型，然后利用具体类型的实例构造接口的itab。核心逻辑在 convT2I 方法。

此时会将具体类型的属性以及方法放置在itab对应的位置，在运行期间，调用接口的方法就是调用的具体类型的方法。

判定一种类型是否满足某个接口时，类型方法方法集如果完全包含接口的方法集，既可以认为该类型实现了该接口。

2.2 interface 转成具体类型（逆变，也叫类型断言）

常见的代码：

type Duck interface {
    Quack()
}

type Cat struct {
    Name string
}

//go:noinline
func (c *Cat) Quack() {
    println(c.Name + " meow")
}

func main() {
    var c Duck = &Cat{Name: "grooming"}
    switch c.(type) {
    case *Cat:
        cat := c.(*Cat)
        cat.Quack()
    }
}

会先比较接口的hash 跟目标类型的hash是否相等，如果相等就认为是目标类型。

3 动态派发机制

动态派发是在运行期间选择具体的多态操作执行的过程，它其实是一种在面向对象语言中非常常见的特性，但是 Go 语言中接口的引入其实也为它带来了动态派发这一特性，也就是对于一个接口类型的方法调用，我们会在运行期间决定具体调用该方法的哪个实现。

如果采用接口调用，跟直接使用具体类型调用，会有一个性能上的差异。主要是接口调用过程中需要进行类型转换。

4 总结

本文主要讲解了接口的用途、分类、数据结构，然后讲解了具体类型跟接口之间的转换。最后简单讲了动态派发的机制，以及性能上小小的影响，不过性能的这一点损耗不足以抵消接口带来的巨大编程优势。

5 参考文献

不错的文章，本文主要参考这篇 https://draveness.me/golang/basic/golang-interface.html
国人翻译的老外的文章 http://xargin.com/go-and-interface/

6 其他

本文是《循序渐进go语言》的第十一篇-《Go-interface》。
如果有疑问，可以直接留言，也可以关注公众号 “链人成长chainerup” 提问留言，或者加入知识星球“链人成长” 与我深度链接~