先来看一段代码
type Runner interface {
Run()
}
type Person struct {
Name string
}
func (p Person) Run() {
fmt.Printf("%s is running\n", p.Name)
}
func main() {
var r Runner
fmt.Println("r:", r == nil)
var p *Person
fmt.Println("p:", p == nil)
r = p
fmt.Println("r:", r == nil)
}
输出的结果是
r: true
p: true
r: false
前两个输出r为nil和p为nil，因为接口类型和指针类型的零值为nil，那么当p赋值给r后，r却不为nil呢？其实是有个接口值的概念
接口值
从概念上来讲，一个接口类型的值（简称接口值）其实有两个部分：分别是 具体类型 和 该类型的值 ，二者称为接口的动态类型 和动态值 ，所以当且仅当接口的动态类型和动态值都为nil时，接口值才为nil
当p赋值给r接口后，r实际结构如图所示
接口的实现原理
Go语言中的接口类型会根据是否包含一组方法而分成两种不同的实现，分别为包含一组方法的iface结构体和不包含任何方法的eface结构体
iface
iface底层是一个结构体，定义如下：
//runtime/runtime2.go
type iface struct {
tab *itab //指向tab的指针
data unsafe.Pointer //指向数据的指针（unsave.Pointer可以储存任何变量地址）
}
//runtime/runtime2.go
type itab struct {
inter *interfacetype
_type *_type
hash uint32 // copy of _type.hash. Used for type switches.
_ [4]byte
fun [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
}
itab用于表示具体类型和接口类型关系，其中 inter 是接口类型定义信息，_type 是具体类型的信息，hash是_type.hash的拷贝，在类型转换时，快速判断目标类型和接口中类型是否一致，fun是实现方法地址列表，虽然fun固定长度为1的数组，但是这其实是一个柔型数组，保存元素的数量是不确定的，如有多个方法，则会按照字典顺序排序
//runtime/type.go
type interfacetype struct {
typ _type
pkgpath name
mhdr []imethod
}
interfacetype是描述接口定义的信息，_type：接口的类型信息，pkgpath是定义接口的包名；，mhdr是接口中定义的函数表，按字典序排序
//runtime/type.go
type _type struct {
size uintptr
ptrdata uintptr // size of memory prefix holding all pointers
hash uint32
tflag tflag
align uint8
fieldalign uint8
kind uint8
alg *typeAlg
// gcdata stores the GC type data for the garbage collector.
// If the KindGCProg bit is set in kind, gcdata is a GC program.
// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
gcdata *byte
str nameOff
ptrToThis typeOff
}
_type是所有类型的公共描述。size是类型的大小，hash是类型的哈希值；tflag是类型的tags，与反射相关，align和fieldalign与内存对齐相关，kind是类型编号，具体定义位于runtime/typekind.go中，gcdata是gc相关信息
eface
//runtime/runtime2.go
type eface struct {
_type *_type
data unsafe.Pointer
}
eface内部同样有两个指针，一个具体类型信息_type结构体的指针，一个指向数据的指针
具体类型转换成接口类型
先来看这一段代码
package main
import "fmt"
type Runner interface {
Run()
}
type Person struct {
Name string
}
func (p Person) Run() {
fmt.Printf("%s is running\n", p.Name)
}
func main() {
var r Runner
r = Person{Name: "song_chh"}
r.Run()
}
编译器在构造itab后调用runtime.convT2I(SB)转换函数，看下函数的实现
func convT2I(tab *itab, elem unsafe.Pointer) (i iface) {
t := tab._type
if raceenabled {
raceReadObjectPC(t, elem, getcallerpc(), funcPC(convT2I))
}
if msanenabled {
msanread(elem, t.size)
}
x := mallocgc(t.size, t, true)
typedmemmove(t, x, elem)
i.tab = tab
i.data = x
return
}
首先根据类型大小调用mallocgc申请一块内存空间，将elem指针的内容拷贝到新空间，将tab赋值给iface的tab，将新内存指针赋值给iface的data，这样一个iface就创建完成
(根据元素类型构造了一个tab结构体赋给iface的tab（动态类型），将元素的指针内容拷贝到新空间，再将新内存指针赋值给iface的data（动态值）)
将示例代码稍作更改，使用结构体指针类型的变量赋值给接口变量
r = &Person{Name: "song_chh"}
首先编译器通过type."".Person(SB)获取Person结构体类型，作为参数调用runtime.newobject()函数，同样的在源码中查看函数定义
import "unsafe"
// runtime/malloc.go
// implementation of new builtin
// compiler (both frontend and SSA backend) knows the signature
// of this function
func newobject(typ *_type) unsafe.Pointer {
return mallocgc(typ.size, typ, true)
}
newobject以Person作为入参，创建新的Person结构体指针，之后由编译器设置值，iface由编译器直接生成
也就是说，r也是独立的Person类型的接口，只是他们指向同一个地址（Person对象的地址）
接口与接口的转换
package main
import "fmt"
type Runner interface {
Run()
Say()
}
type Sayer interface {
Say()
}
type Person struct {
Name string
}
func (p Person) Run() {
fmt.Printf("%s is running\n", p.Name)
}
func (p Person) Say() {
fmt.Printf("hello, %s", p.Name)
}
func main() {
var r Runner
r = Person{Name: "song_chh"}
var s Sayer
s = r
s.Say()
}
增加Sayer接口定义，包含Say()方法，在main函数中声明一个Sayer变量，并将Runner接口变量赋值给Sayer变量。因为Person实现了Say()方法，所以说Person既实现了是Runner接口，又实现了Sayer接口
在执行期间，调用runtime.convI2I进行接口转换，接下来看下源代码
func convI2I(inter *interfacetype, i iface) (r iface) {
tab := i.tab
if tab == nil {
return
}
if tab.inter == inter {
r.tab = tab
r.data = i.data
return
}
r.tab = (inter, tab._type, false)
r.data = i.data
return
}
函数参数inter表示接口的类型，由编译器生成，即type."".Sayer(SB)，i 是绑定实体的接口， r 是转换后新的接口，如果要转换的接口是同一类型，则直接把 i 的tab和data给新接口 r ，将 r 返回。如果要转换的接口不是同一类型，则通过getitab生成一个新的tab复制给r.tab，然后将 r 返回
