Golang中的Interface详解

Golang中的Interface详解

Interface

Interfaces in Go provide a way to specify the behavior of an object

这是"Effective go" 中对interface的定义。Golang的多态是根据duck typing（你看着像，我就认为你是）的方式来实现。举个例子：

func main() {
	fishObj := new(fish)
	dogObj := new(dog)
	var duckObj duck = fishObj
	duckObj.eat()

	var duckObj1 duck = dogObj
	duckObj1.eat()
}

type duck interface {
	eat()
}

type fish struct {
}

func (f *fish) eat() {
	fmt.Println("fish eat")
}

type dog struct {
}

func (f *dog) eat() {
	fmt.Println("dog eat")
}

fish eat
dog eat

fish和dog 都是实现了duck的eat函数，golang就认为fish和dog继承了duck，并可以做类型转换，那么问题来了，golang时候怎么知道调用的是哪个函数呢？要回答这个问题，必须从interface的内存结构开始讲起。

type Binary uint64

func (i Binary) String() string {
    return strconv.Uitob64(i.Get(), 2)
}

func (i Binary) Get() uint64 {
    return uint64(i)
}

这个Binary实现了Stringer的String接口，将b转换为stringer会发生什么事情呢，如图：

在执行了s:=Stringer(b)后，s的结构包含两个部分，一个是itable的指针，另外一个是存储binary值得指针。itable里面包含了一个所属的真正类型Type，调用s.(type)可得。另外还包含了一个调用函数指针列表，这里的函数列表必须和Stringer的一样。可以看到调用s.String() 其实就相当于s.tab->fun[0](s.data)。那么itable是怎么生成的呢？

首先编译器会为interface类型生成method table list，在运行时态，具体的实现类，会去interface的method table list里去匹配这些方法，并将函数指针并记录到itable，另外为了节省计算时间，匹配信息也会缓存起来，下次就不用再去找寻匹配。

这与C++的多态实现可以对比一下，C++也会生成method table list，不过继承关系是确定的，所以不用去匹配，只需要在运行期间，将具体实现类的函数地址写入到vtable里即可。

空Interface

interface{} 没有任何方法，按照duck type的原则，所有类型都可以转为interface{}，经常你会看到如下代码：

var value interface{} // Value provided by caller.
switch str := value.(type) {
case string:
    return str
case Stringer:
    return str.String()
}

因为这个特性interface{}，大量的用于函数参数，以及函数返回。其实有点像C++的Template的实现，对具体类型进行抽象。

不过这里要强调注意[]interface{}，这是interface{}的slice，不是interface{}，所以不能代表所有类型。下面的这种写法就是典型的错误写法。

var dataSlice []int = foo()
var interfaceSlice []interface{} = dataSlice

正确的写法应该是：

var dataSlice []int = foo()
var interfaceSlice []interface{} = make([]interface{}, len(dataSlice))
for i, d := range dataSlice {
	interfaceSlice[i] = d
}

Interface的Receiver的选择

在了解这个之前，我们先来说说，receiver的两种情况，一个是value实现，一个是pointer实现。

func main() {
	fishObj := new(fish)
	dogObj := new(dog)
	var duckObj duck = fishObj
	duckObj.eat()
	fmt.Println("fish food:", fishObj.Food)

	var duckObj1 duck = dogObj
	duckObj1.eat()
	fmt.Println("dog food:", dogObj.Food)
}

type duck interface {
	eat()
}

type fish struct {
	Food string
}

func (f fish) eat() {
	f.Food = "small fish"
	fmt.Println("fish eat", f.Food)
}

type dog struct {
	Food string
}

func (d *dog) eat() {
	d.Food = "bone"
	fmt.Println("dog eat", d.Food)
}

fish eat small fish
fish food: 
dog eat bone
dog food: bone

通过上面例子可以看出，采用pointer的dog，Food修改对外是可见的，而采用value的fish，Food修改对外是不可见，可以理解为是一种拷贝。那么现在我们来理解interface的receiver的选择。

	func main() {
	animals := []duck{dog{}, fish{}}
	for _, animal := range animals {
		animal.eat()
	}
}

type duck interface {
	eat()
}

type fish struct {
	Food string
}

func (f fish) eat() {
	f.Food = "small fish"
	fmt.Println("fish eat", f.Food)
}

type dog struct {
	Food string
}

func (d *dog) eat() {
	d.Food = "bone"
	fmt.Println("dog eat", d.Food)
}

这个代码其实会报类似这种错误：

cannot use (dog literal) (value of type dog) as duck value in array or slice literal: missing method eat (eat has pointer receiver)

dog的实现类是一个pointer，而animals的slice是传进去的是一个value，那么这时候就会找出不匹配，编译器就会认为找不到该类型匹配的eat函数。我们需要做如下修改：

animals := []duck{&dog{}, fish{}}

但是还有一种情况，如果receiver都是用value实现的，不管参数是value还是pointer都能ok，原因就是如果传入的是pointer，编译器会自动转换为value。毕竟通过pointer是能找到对应的value，然后在执行copy即可，但是通过copy value是无法找到原始指针的。

func main() {
	animals := []duck{&dog{}, &fish{}}
	for _, animal := range animals {
		animal.eat()
	}
}

type duck interface {
	eat()
}

type fish struct {
	Food string
}

func (f fish) eat() {
	f.Food = "small fish"
	fmt.Println("fish eat", f.Food)
}

type dog struct {
	Food string
}

func (d dog) eat() {
	d.Food = "bone"
	fmt.Println("dog eat", d.Food)
}

Reference

research!rsc: Go Data Structures: Interfaces

理解 Go interface 的 5 个关键点

Effective Go

golang/go