背景
除了了与基础性能息息相关的网络和内存管理之外，Golang 给人印象最深的一个特性就是 Inerface 数据结构了，Interface 距离业务系统非常近，其独特的静态编译，动态检测的类型定义方式为提供了非常好的编程灵活性，大大简化了业务系统设计的复杂程度。
概述
通过 Interface 你可以像使用Python、JavaScript这类动态类型那样的完成对象的类型动态转换，与此同时作为一门传统编译型语言，在编译过程中，编译器会帮你找到程序中类型不匹配的问题。
下面我们尝试通过一个简单的例子，看看 Interface 如何使用：
// 首先，声明一个拥有两个函数的接口类型 ReadCloser，以及一个接收 ReadCloser 接口类型参数的函数
type ReadCloser interface {
Read(b []byte) (n int, err os.Error)
Close()
}
func ReadAndClose(r ReadCloser, buf []byte) (n int, err os.Error) {
for len(buf) > 0 && err == nil {
var nr int
nr, err = r.Read(buf)
n += nr
buf = buf[nr:]
}
r.Close()
return
}
// 接下来，然后声明一个拥有一个函数的接口类型 Stringer，以及一个接口 interface{} 接口类型的函数
type Stringer interface {
String() string
}
func ToString(any interface{}) string {
if v, ok := any.(Stringer); ok {
return v.String()
}
switch v := any.(type) {
case int:
return strconv.Itoa(v)
case float:
return strconv.Ftoa(v, 'g', -1)
}
return "???"
}
// 最后是测试代码
type stringer struct {
data string
}
func test1() {
stringer s
t := "hello world"
ReadAndClose(s, t)
}
func test2() {
stringer s
ToString(s)
}
函数 test1 中由于我们的 stringer 数据结构并没有实现 Read 和 Close 函数，此处会引起编译时的报错，而 test2 中由于使用 interface{} 编译器不会它为绑定任何静态类型检测，因此编译不会出错，函数体中第一句是一个类型断言，如果 any 对象可以转换成 Stringer 接口类，则 ok 为 true；如果不能完成转换，则 ok 为 false。如果类型转换成功，则调用 String 函数并返回结果，如果转换失败，则做一个类型判断，判断 any 的类型是否是 int 或者 float，如果是则调用 strconv 将数值转换成字符串，如果不是则返回 "???"。
编译器是如何判断 any 对象是否可以完成类型转换呢？
编译器通过检查 any 所对应的函数表中是否存在 String 这个函数，如果存在则可以完成类型转换，如果不存在则无法完成。
PS: 需要说明的是 "switch v := any.(type)" 一般也成为 type-switch，中文翻译为类型分支，可以算作做 type assertion 的语法糖，每个分支会被编译器解释为一句包含 type assertion 的 case 语句，示例如下：
package main
import (
"fmt"
"strconv"
)
type Stringer interface {
String() string
}
type Binary uint64
func (i Binary) String() string {
return strconv.Uitob64(i.Get(), 2)
}
func (i Binary) Get() uint64 {
return uint64(i)
}
func main() {
b := Binary(200)
s := Stringer(b)
fmt.Println(s.String())
}
使用 Golang 提供的编译工具转换成 Plan9 汇编，截取 test1 函数的代码段
go tool compile -S main.go
main.test1 STEXT size=261 args=0x10 locals=0x50 funcid=0x0 align=0x0
+ 0x0000 00000 (main.go:7) TEXT main.test1(SB), ABIInternal, $80-16
+ 0x0000 00000 (main.go:7) CMPQ SP, 16(R14)
+ 0x0004 00004 (main.go:7) PCDATA $0, $-2
+ 0x0004 00004 (main.go:7) JLS 229
+ 0x000a 00010 (main.go:7) PCDATA $0, $-1
+ 0x000a 00010 (main.go:7) SUBQ $80, SP
+ 0x000e 00014 (main.go:7) MOVQ BP, 72(SP)
+ 0x0013 00019 (main.go:7) LEAQ 72(SP), BP
+ 0x0018 00024 (main.go:7) MOVQ AX, main.any+88(FP)
+ 0x001d 00029 (main.go:7) MOVQ BX, main.any+96(FP)
+ 0x0022 00034 (main.go:7) FUNCDATA $0, gclocals·IuErl7MOXaHVn7EZYWzfFA==(SB)
+ 0x0022 00034 (main.go:7) FUNCDATA $1, gclocals·EXTrhv4b3ahawRWAszmcVw==(SB)
+ 0x0022 00034 (main.go:7) FUNCDATA $2, main.test1.stkobj(SB)
+ 0x0022 00034 (main.go:7) FUNCDATA $5, main.test1.arginfo1(SB)
+ 0x0022 00034 (main.go:7) FUNCDATA $6, main.test1.argliveinfo(SB)
+ 0x0022 00034 (main.go:7) PCDATA $3, $1
+ 0x0022 00034 (main.go:8) TESTQ AX, AX
+ 0x0025 00037 (main.go:8) JEQ 219
+ 0x002b 00043 (main.go:8) MOVL 16(AX), DX
+ 0x002e 00046 (main.go:8) CMPL DX, $1810709754
+ 0x0034 00052 (main.go:8) JNE 137
++ 0x0036 00054 (main.go:9) LEAQ type.int32(SB), DX
+ 0x003d 00061 (main.go:9) NOP
+ 0x0040 00064 (main.go:9) CMPQ AX, DX
+ 0x0043 00067 (main.go:9) JNE 219
+ 0x0049 00073 (main.go:10) MOVUPS X15, main..autotmp_17+56(SP)
++ 0x004f 00079 (main.go:10) LEAQ type.string(SB), DX
+ 0x0056 00086 (main.go:10) MOVQ DX, main..autotmp_17+56(SP)
+ 0x005b 00091 (main.go:10) LEAQ main..stmp_0(SB), DX
+ 0x0062 00098 (main.go:10) MOVQ DX, main..autotmp_17+64(SP)
+ 0x0067 00103 (<unknown line number>) NOP
+ 0x0067 00103 ($GOROOT/src/fmt/print.go:294) MOVQ os.Stdout(SB), BX
+ 0x006e 00110 ($GOROOT/src/fmt/print.go:294) LEAQ go.itab.*os.File,io.Writer(SB), AX
+ 0x0075 00117 ($GOROOT/src/fmt/print.go:294) LEAQ main..autotmp_17+56(SP), CX
+ 0x007a 00122 ($GOROOT/src/fmt/print.go:294) MOVL $1, DI
+ 0x007f 00127 ($GOROOT/src/fmt/print.go:294) MOVQ DI, SI
+ 0x0082 00130 ($GOROOT/src/fmt/print.go:294) PCDATA $1, $1
+ 0x0082 00130 ($GOROOT/src/fmt/print.go:294) CALL fmt.Fprintln(SB)
+ 0x0087 00135 (main.go:8) JMP 219
+ 0x0089 00137 (main.go:8) CMPL DX, $-1920832363
+ 0x008f 00143 (main.go:8) JNE 219
++ 0x0091 00145 (main.go:11) LEAQ type.float32(SB), DX
+ 0x0098 00152 (main.go:11) CMPQ AX, DX
+ 0x009b 00155 (main.go:11) JNE 219
+ 0x009d 00157 (main.go:12) MOVUPS X15, main..autotmp_19+40(SP)
++ 0x00a3 00163 (main.go:12) LEAQ type.string(SB), DX
+ 0x00aa 00170 (main.go:12) MOVQ DX, main..autotmp_19+40(SP)
+ 0x00af 00175 (main.go:12) LEAQ main..stmp_1(SB), DX
+ 0x00b6 00182 (main.go:12) MOVQ DX, main..autotmp_19+48(SP)
+ 0x00bb 00187 (<unknown line number>) NOP
+ 0x00bb 00187 ($GOROOT/src/fmt/print.go:294) MOVQ os.Stdout(SB), BX
+ 0x00c2 00194 ($GOROOT/src/fmt/print.go:294) LEAQ go.itab.*os.File,io.Writer(SB), AX
+ 0x00c9 00201 ($GOROOT/src/fmt/print.go:294) LEAQ main..autotmp_19+40(SP), CX
+ 0x00ce 00206 ($GOROOT/src/fmt/print.go:294) MOVL $1, DI
+ 0x00d3 00211 ($GOROOT/src/fmt/print.go:294) MOVQ DI, SI
+ 0x00d6 00214 ($GOROOT/src/fmt/print.go:294) CALL fmt.Fprintln(SB)
+ 0x00db 00219 (main.go:14) PCDATA $1, $-1
+ 0x00db 00219 (main.go:14) MOVQ 72(SP), BP
+ 0x00e0 00224 (main.go:14) ADDQ $80, SP
+ 0x00e4 00228 (main.go:14) RET
+ 0x00e5 00229 (main.go:14) NOP
+ 0x00e5 00229 (main.go:7) PCDATA $1, $-1
+ 0x00e5 00229 (main.go:7) PCDATA $0, $-2
+ 0x00e5 00229 (main.go:7) MOVQ AX, 8(SP)
+ 0x00ea 00234 (main.go:7) MOVQ BX, 16(SP)
+ 0x00ef 00239 (main.go:7) CALL runtime.morestack_noctxt(SB)
+ 0x00f4 00244 (main.go:7) MOVQ 8(SP), AX
+ 0x00f9 00249 (main.go:7) MOVQ 16(SP), BX
+ 0x00fe 00254 (main.go:7) PCDATA $0, $-1
+ 0x00fe 00254 (main.go:7) NOP
+ 0x0100 00256 (main.go:7) JMP 0
// 省略后面的非函数声明部分的源码
// ...
可以看到四行 type assertion 被标记出来了(行首标记为++)。
回到类型断言的问题来，接下来看一个简单的例子。
type Binary uint64
var _ Stringer = (*Binary)(nil)
func (i Binary) String() string {
return strconv.Uitob64(i.Get(), 2)
}
func (i Binary) Get() uint64 {
return uint64(i)
}
如果我们定义一个 Binary 类型的变量将其传入 ToString() 函数时，由于我们为 Binary 类型定义了 String() 函数，因此 any.(Stringer) 可以将 Binary 转换成 Stringer 接口类型。这就是我们说的 Golang 接口可以实现 ”鸭子类型“ 的威力，我们无需显示的声明接口类型，编译器会通过接口比对的方式为我们校验类型是否匹配。需要主要是工程上，Golang 鸭子类型虽然有灵活性的优点，但是一般跨包或是项目去实现某个接口时，程序会变的可读性非常差并且极容器出错，那我们能不能像 Java 中的接口一样，让我们知道一个接口中我们需要实现具体定义哪些函数，类似于”接口继承”的语法。
Interface 实现
Golang 的类型设计原则中，一般包含 type 和 value 两部分， Interface 的实现也遵循这个原则，不过，golang 编译器会根据 interface 是否包含有 method，实现上用两种不同数据结构来：一种是有 method 的 interface 对应的数据结构为 iface；一种是没有 method 的 empty interface 对应的数据结构为 eface。
// eface 数据结构
type eface struct {
_type *_type // 类型信息
data unsafe.Pointer // 原数据存放的位置
}
// 大多数的 Golang 中的数据结构其底层都会对应一种 _type 类型的数据结构
type _type struct {
size uintptr // type size
ptrdata uintptr // size of memory prefix holding all pointers
hash uint32 // hash of type; avoids computation in hash tables
tflag tflag // extra type information flags
align uint8 // alignment of variable with this type
fieldalign uint8 // alignment of struct field with this type
kind uint8 // enumeration for C
alg *typeAlg // algorithm table
gcdata *byte // garbage collection data
str nameOff // string form
ptrToThis typeOff // type for pointer to this type, may be zero
}
// iface 数据结构
type iface struct {
tab *itab // 可以理解为含有接口函数表的类型信息
data unsafe.Pointer // 原数据存放的位置
}
type itab struct {
inter *interfacetype // interface 类型信息
_type *_type // 原数据结构的类型信息
link *itab
bad int32
inhash int32 // 只有 itab 被拥有记录在了 hash 表中
fun [1]uintptr // 函数表入口指针
}
// 函数名声明
type imethod struct {
name nameOff
ityp typeOff
}
type interfacetype struct {
typ _type // interface type
pkgpath name // 包路径
mhdr []imethod // 接口函数名声明表
}
需要说明：
- 对于非空的接口，其对应的类型有两个，一般称为 interface type 和 concrete type， interface type 保存在 itab.inter.typ 中，concrete type 保存在 itab._type 中。
- itab 中存放了两张函数表，一张表对应接口对应实际接收到的函数，通过 itab.fun[0] 指向第一个函数对应的函数指针，后续函数根据函数名的字典值有小到大的排列，与C++中对象的虚函数表及虚函数的定义方式非常类似，另外一张表对应接口定制是函数声明。
下面通过一段代码样例，展示 Golang 如何实现 interface 对象的创建及类型转换。
package main
import (
"fmt"
"strconv"
)
type Stringer interface {
String() string
}
type Binary uint64
func (i Binary) String() string {
return strconv.Uitob64(i.Get(), 2)
}
func (i Binary) Get() uint64 {
return uint64(i)
}
func main() {
1 b := Binary(200)
2 var a interface{} = b
3 s := Stringer(b)
4 fmt.Println(s.String())
}
main 函数代码第一行，由于 Binary 没有实现任何函数时，因此 对象 b 只是一个普通的数据结构，其对应的内存区域存放对应的 uint64 数值。
Binary
代码第二行，尝试创建一个空接口对象，然后将 Binary 对象赋值给它，编译器会构造一个 eface 类型的数据结构，然后将 Binary 对应的 _type 以及 Binary 对应的数据保存下来。
空接口
代码第三行，创建一个 Stringer 类型的接口对象，然后将 Binary 对象赋值给它，编译器会构造一个 iface 类型的数据结构，itab中分别保存 Binary 和 Stringer 对应的 _type 以及 定义了 Binary 作为接收器的函数指针。
Stringer
类型断言(Type Assertion)
根据前面看过了的例子，我们知道类型断言的语句会被替换成 runtime 包中的 assert 函数，那我们把这两个函数的源码贴出来，需要说明一下 assertI2I 是 iface 类型的接口类型断言对应的函数，assertE2I 是 eface 类型的接口类型断言对应的函数。
类型断言的工作其实非常简单，先判断 itab.inter 这个接口类型是否相同，如果相同直接返回，如果不同则进入 getitab 进行处理，重点看一下这个函数。
func assertI2I(inter *interfacetype, tab *itab) *itab {
if tab == nil {
// explicit conversions require non-nil interface value.
panic(&TypeAssertionError{nil, nil, &inter.typ, ""})
}
if tab.inter == inter {
return tab
}
//
return getitab(inter, tab._type, false)
}
func assertI2I2(inter *interfacetype, i iface) (r iface) {
tab := i.tab
if tab == nil {
return
}
if tab.inter != inter {
tab = getitab(inter, tab._type, true)
if tab == nil {
return
}
}
r.tab = tab
r.data = i.data
return
}
func assertE2I(inter *interfacetype, t *_type) *itab {
if t == nil {
// explicit conversions require non-nil interface value.
panic(&TypeAssertionError{nil, nil, &inter.typ, ""})
}
return getitab(inter, t, false)
}
func assertE2I2(inter *interfacetype, e eface) (r iface) {
t := e._type
if t == nil {
return
}
tab := getitab(inter, t, true)
if tab == nil {
return
}
r.tab = tab
r.data = e.data
return
}
func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
// _, ok := a.(interface{}) 这样的空接口断言直接抛出错误。
if len(inter.mhdr) == 0 {
throw("internal error - misuse of itab")
}
// 判断传入类型是否为 Uncomon type
// Golang 类型定义这里就不展开做详细的讲解了，Uncommon Type可以简单理解为一个绑定了 Methods 的数据结构。
if typ.tflag&tflagUncommon == 0 {
if canfail {
return nil
}
name := inter.typ.nameOff(inter.mhdr[0].name)
panic(&TypeAssertionError{nil, typ, &inter.typ, name.name()})
}
var m *itab
// itabTable 是编译器创建的 itab 缓存哈希表，先通过原子操作查表找到 itab 如果没有找到，则再通过加锁方式查找一遍
t := (*itabTableType)(atomic.Loadp(unsafe.Pointer(&itabTable)))
if m = t.find(inter, typ); m != nil {
goto finish
}
// Not found. Grab the lock and try again.
lock(&itabLock)
if m = itabTable.find(inter, typ); m != nil {
unlock(&itabLock)
goto finish
}
// 经过两次查表都没有找到 itab 对应的类型，就创建一个新的 itab 对象，并将其存入 itabTable 中
m = (*itab)(persistentalloc(unsafe.Sizeof(itab{})+uintptr(len(inter.mhdr)-1)*goarch.PtrSize, 0, &memstats.other_sys))
m.inter = inter
m._type = typ
m.hash = 0
m.init()
itabAdd(m)
unlock(&itabLock)
finish:
if m.fun[0] != 0 {
return m
}
if canfail {
return nil
}
// this can only happen if the conversion
// was already done once using the , ok form
// and we have a cached negative result.
// The cached result doesn't record which
// interface function was missing, so initialize
// the itab again to get the missing function name.
panic(&TypeAssertionError{concrete: typ, asserted: &inter.typ, missingMethod: m.init()})
}
更多技术分享浏览我的博客：
参考
本文由mdnice多平台发布
