接口是Go组合设计思想的核心语法。
基本概念
接口类型定义
接口类型是由
type和interface关键字定义的一组方法集合
典型的接口类型定义如下：
type I interface {
M1()
M2(int, string)
}
从接口声明的形式可以看到，接口定义的方法集合中的方法只需要方法名、参数列表和返回值列表，且可以省略参数名和返回值名，这也意味着区分不同方法的标准不在于形参名或具名返回值。
Go要求接口类型声明中的方法必须是具名的，并且方法名在其所属接口类型的方法集合中是唯一的。如果使用嵌入接口类型，允许嵌入的不同接口类型的方法集合存在交集，但是交集中的方法名字和签名也必须相同：
type Interface1 interface {
M1()
}
type Interface2 interface {
M1(string)
M2()
}
type Interface3 interface{
Interface1
Interface2 // 编译器错误：duplicate method M1
M3()
}
Go允许接口的方法集合中声明首字母小写的非导出方法，通常一个接口类型的方法集合包含非导出方法时，这个接口类型自身也是非导出的，适用范围仅局限于同一个包内，使用的场景并不多。
除了常规接口类型，还可以定义方法集合为空的接口类型（空接口类型），这样的接口类型通常不需要显式定义，而是直接使用interface{}字面值来代表所有空接口类型。自Go 1.18版本起，Go引入了一个新的预定义标识符any，是interface{}的类型别名，在任何使用interface{}的地方，都可以使用any替代。
接口类型一旦被定义，就可以像其他Go类型一样用于声明变量，例如：
var err error
var r io.Reader
这些类型为接口类型的变量称为接口类型变量。如果没有被显式赋予初始值，接口类型变量的默认值为nil。如果要为接口类型变量显式赋值，则必须选择合法的右值。
Go规定，如果一个类型T的方法集合是接口类型I的方法集合的等价集合或超集，就说明类型T实现了接口类型I，意味着类型T的变量可以作为合法的右值赋值给接口类型I的变量。
对于空接口类型变量，由于其方法集合为空，这意味着任何类型都自动实现了空接口类型，因此，任何类型的值都可以作为右值赋值给空接口类型的变量：
var i interface{} = 15 // 正确
i = "hello, golang" // 正确
type T struct{}
var t T
i = t // 正确
i = &t // 正确
Go中可以通过接口类型变量还原右值的类型与值信息，这个过程被称为类型断言，通常的语法形式为：
v, ok := i.(T)
其中，i是某个接口类型变量。如果T是一个非接口类型，并且是想要还原的类型，这段代码的作用就是断言存储在接口类型变量i中的值的类型为T。
如果接口类型变量i之前被赋予的值确实是T类型的值，那么执行上述语句后，变量ok的值将为true，变量v的类型为T，值是之前变量i的右值。如果变量i之前被赋予的值不是T类型的值，那么执行上述语句后，变量ok的值为false，而变量v的类型虽然为T，但其值是T类型的零值。
类型断言也支持以下语法形式：
v := i.(T)
如果使用这种写法，当变量i被赋予的值不是T类型的值时，这个语句会导致程序抛出panic，因此除非确定接口变量包含特定类型的值，否则不推荐使用这种形式进行类型断言。
package main
import "fmt"
func main() {
// ch15/typeassert1.go
var a int64 = 13
var i interface{} = a
v1, ok := i.(int64)
fmt.Printf("v1=%d, the type of v1 is %T, ok=%t\n", v1, v1, ok) // 输出: v1=13, the type of v1 is int64, ok=true
v2, ok := i.(string)
fmt.Printf("v2=%s, the type of v2 is %T, ok=%t\n", v2, v2, ok) // 输出: v2=, the type of v2 is string, ok=false
v3 := i.(int64)
fmt.Printf("v3=%d, the type of v3 is %T\n", v3, v3) // 输出: v3=13, the type of v3 is int64
v4 := i.([]int) // 导致抛出一个panic：interface conversion: interface {} is int64, not []int
fmt.Printf("the type of v4 is %T\n", v4)
}
在以上代码中，如果v, ok := i.(T)中的T是一个接口类型，那么类型断言的语义变为：断言i的值实现了接口类型T。如果断言成功，变量v的类型将是变量i的值的实际类型而非接口类型T；如果断言失败，变量ok的值为false，变量v的类型信息为接口类型T，值为nil。
接口定义惯例
接口类型的核心在于通过抽象类型的行为形成契约，建立双方共同遵守的约定，从而最大限度地降低双方的耦合度。
- 隐式契约，无需签署，自动生效。Go中，接口类型与其实现者之间的关系是隐式的。与Java等其他编程语言不同，Go不要求实现者显式声明
implements关键字来表示实现了某个接口。只要一个类型实现了接口方法集合中的全部方法，它就被认为遵守了契约并立即生效。 - 倾向于小契约。如果契约过于复杂，会束缚手脚，减少灵活性并抑制代码表现力，所以Go提倡使用小契约，意味着尽量定义小接口，通常包含1~3个方法。
小接口的优势可以总结为以下3点：
- 接口越小，抽象程度越高。计算机程序本质上是对真实世界的抽象与重构。抽象过程涉及去除具体且次要的方面，提取共同的主要特征。不同的抽象层次，会导致抽象出的概念所涵盖的事物的集合有所不同。抽象程度越高，对应的集合空间越大；反之，抽象程度越低，则越接近事物的真实面貌，对应的集合空间就越小。因此，接口越小（即接口方法越少），其抽象程度越高，能够涵盖的事物集合也就越大。在这种情况下，无方法的空接口interface{}达到极限，其抽象涵盖了Go世界中的所有事物。
- 小接口易于实现和测试。这是一个显而易见的优点。小接口包含的方法较少，一般情况下只有一个或少数几个。所以，要想满足这一接口，只需要实现一个方法或者少数几个方法就可以了，这显然比实现拥有较多方法的接口容易得多。尤其是在单元测试环节，构建类型来实现只有少量方法的接口要比实现拥有较多方法的接口所需的工作量小得多。
- 小接口表示的契约职责单一，易于复用组合。Go开发者一般会尝试通过嵌入其他已有接口类型的方式来构建新接口类型，例如，通过嵌入io.Reader和io.Writer来构建io.ReadWriter。当构建新的接口时，如果有众多候选接口类型，我们该如何选择呢？显然，我们会倾向于选择那些只包含必要契约职责的小接口，避免引入不需要的契约职责。在这种情况下，拥有单一或少数方法的小接口便更有可能成为我们的首选，而那些拥有较多方法的大接口可能会因引入过多不需要的契约职责而被放弃。由此可见，小接口更契合Go的组合设计思想，也更容易发挥出组合的优势。
接口的实现
静态特性与动态特性
接口的静态特性体现在接口类型变量具有静态类型，拥有静态类型意味着编译器会在编译阶段对所有接口类型变量的赋值操作进行类型检查，确保右值的类型实现了该接口方法集合中的所有方法。
接口的动态特性体现在接口类型变量在运行时存储了右值的真实类型信息，这个右值的真实类型被称为接口类型变量的动态类型。例如：
var err error
err = errors.New("error1")
fmt.Printf("%T\n", err) // *errors.errorString
在以上示例中，通过errors.New构造了一个错误值，并赋值给error接口类型变量err。使用fmt.Printf函数输出了变量的动态类型。
接口类型变量在程序运行时可以被赋值为不同的动态类型，这让Go可以像动态编程语言一样拥有鸭子类型（duck typing）的灵活性。例如：
package main
import "fmt"
// 定义一个接口
type Speaker interface {
Speak() string
}
// 定义不同的类型，它们都实现了Speak方法
type Dog struct {
Name string
}
func (d Dog) Speak() string {
return "Woof!"
}
type Cat struct {
Name string
}
func (c Cat) Speak() string {
return "Meow!"
}
type Person struct {
Name string
}
func (p Person) Speak() string {
return "Hello!"
}
// 这个函数接受Speaker接口类型
func MakeSound(s Speaker) {
fmt.Printf("%s says: %s\n", getTypeName(s), s.Speak())
}
func getTypeName(s Speaker) string {
return fmt.Sprintf("%T", s)
}
func main() {
// 鸭子类型的体现：只要实现了Speak方法，就可以作为Speaker使用
var s Speaker
// 运行时动态改变接口变量的类型
s = Dog{Name: "Buddy"}
MakeSound(s) // 输出: main.Dog says: Woof!
s = Cat{Name: "Whiskers"}
MakeSound(s) // 输出: main.Cat says: Meow!
s = Person{Name: "Alice"}
MakeSound(s) // 输出: main.Person says: Hello!
// 演示接口变量可以在运行时被赋值为不同的动态类型
animals := []Speaker{
Dog{Name: "Max"},
Cat{Name: "Luna"},
Person{Name: "Bob"},
}
for _, animal := range animals {
MakeSound(animal)
}
// 输出:
// main.Dog says: Woof!
// main.Cat says: Meow!
// main.Person says: Hello!
}
与动态编程语言不同的是，Go接口还保证动态特性使用时的安全性。编译器可以在编译阶段捕捉到明显的类型赋值错误,避免在运行时才发现问题。
nil的error值
type MyError struct {
error
}
var ErrBad = MyError{
error: errors.New("bad things happened"),
}
func bad() bool {
return false
}
func returnsError() error {
var p *MyError = nil
if bad() {
p = &ErrBad
}
return p
}
func main() {
err := returnsError()
if err != nil {
fmt.Printf("error occur: %+v\n", err)
return
}
fmt.Println("ok")
}
在这个示例中，returnsError函数中定义了*MyError类型的变量p，由于bad返回值为false，直接将p返回，main中对err的判断应该相等才对，但实际上会进入错误处理的分支，这与预期值可能不符。造成这种情况的原因是接口类型变量的内部表示不同。
接口类型"动静兼备"的特性决定了其变量的内部表示不像静态类型变量那样简单。内部表示通常如下：
// $GOROOT/src/runtime/runtime2.go
type iface struct {
tab *itab
data unsafe.Pointer
}
type eface struct {
_type *_type
data unsafe.Pointer
}
-
eface用于表示没有方法的空接口（interface{}类型的变量） -
iface用于表示拥有方法的其他接口类型变量
这两个结构中，第二个字段相同，都是指向当前赋值给该接口类型变量的动态类型变量的值。不同点在于eface表示的空接口类型并没有方法列表，因此第一个指针字段指向一个_type结构，这个结构保存了该接口类型变量的动态类型信息。而iface除了要存储动态类型信息以外，还要存储接口本身的信息（如接口的类型信息、方法列表信息）以及动态类型实现的方法信息，因此iface的第一个字段指向一个itab结构。
有以下示例：
type T struct {
n int
s string
}
func main() {
var t = T {
n: 17,
s: "hello, interface",
}
var ei interface{} = t // Go运行时使用eface结构表示ei
_ = ei
}
空接口类型变量在Go运行时表示为：
type T struct {
n int
s string
}
func (T) M1() {}
func (T) M2() {}
type NonEmptyInterface interface {
M1()
M2()
}
func main() {
var t = T{
n: 18,
s: "hello, interface",
}
var i NonEmptyInterface = t
_ = i
}
iface类型的内存表示为：
从以上示意图中可以看到，即使将一个结构中的某个变量指向了nil，这个接口的data字段为空，但对应的类型信息并不为空，而是指向定义的类型信息，因此在之前的示例中err与nil(0x0, 0x0)并不相等。
package main
import (
"fmt"
"unsafe"
)
// 定义一个带方法的类型
type T struct {
n int
s string
}
func (T) M1() {}
func (T) M2() {}
// 定义一个非空接口
type NonEmptyInterface interface {
M1()
M2()
}
// eface结构（空接口的内部表示）
type eface struct {
_type uintptr
data uintptr
}
// iface结构（非空接口的内部表示）
type iface struct {
tab uintptr
data uintptr
}
func main() {
fmt.Println("=== 空接口(eface)的内部表示 ===")
var t1 = T{
n: 17,
s: "hello, interface",
}
var ei interface{} = t1
// 使用println输出空接口的内部表示
println("空接口 ei 的内部表示:")
println(ei) // 输出: (0x10a8e60,0x14000010030) 格式为 (type, data)
// 通过unsafe转换查看eface结构
efacePtr := (*eface)(unsafe.Pointer(&ei))
fmt.Printf("eface._type = 0x%x (类型信息地址)\n", efacePtr._type) // 输出: eface._type = 0x10a8e60 (类型信息地址)
fmt.Printf("eface.data = 0x%x (数据地址)\n", efacePtr.data) // 输出: eface.data = 0x14000010030 (数据地址)
fmt.Println()
fmt.Println("=== 非空接口(iface)的内部表示 ===")
var t2 = T{
n: 18,
s: "hello, interface",
}
var i NonEmptyInterface = t2
// 使用println输出非空接口的内部表示
println("非空接口 i 的内部表示:")
println(i) // 输出: (0x10c3f18,0x14000010048) 格式为 (itab, data)
// 通过unsafe转换查看iface结构
ifacePtr := (*iface)(unsafe.Pointer(&i))
fmt.Printf("iface.tab = 0x%x (itab地址，包含类型和方法信息)\n", ifacePtr.tab) // 输出: iface.tab = 0x10c3f18 (itab地址，包含类型和方法信息)
fmt.Printf("iface.data = 0x%x (数据地址)\n", ifacePtr.data) // 输出: iface.data = 0x14000010048 (数据地址)
fmt.Println()
fmt.Println("=== nil接口的内部表示 ===")
var nilEmpty interface{} = nil
var nilNonEmpty NonEmptyInterface = nil
println("nil空接口的内部表示:")
println(nilEmpty) // 输出: (0x0,0x0) 两个字段都为0
println("nil非空接口的内部表示:")
println(nilNonEmpty) // 输出: (0x0,0x0) 两个字段都为0
fmt.Println()
fmt.Println("=== nil指针赋值给接口的内部表示 ===")
var nilPtr *T = nil
var ei2 interface{} = nilPtr
var i2 NonEmptyInterface = nilPtr
println("nil指针赋值给空接口:")
println(ei2) // 输出: (0x10a9020,0x0) type字段非0，data字段为0
println("nil指针赋值给非空接口:")
println(i2) // 输出: (0x10c3f08,0x0) tab字段非0，data字段为0
// 这就是为什么 nil error 值不等于 nil 的原因
fmt.Println()
fmt.Println("=== 验证nil error问题 ===")
fmt.Printf("ei2 == nil: %v\n", ei2 == nil) // 输出: ei2 == nil: false
fmt.Printf("i2 == nil: %v\n", i2 == nil) // 输出: i2 == nil: false
fmt.Printf("nilEmpty == nil: %v\n", nilEmpty == nil) // 输出: nilEmpty == nil: true
fmt.Printf("nilNonEmpty == nil: %v\n", nilNonEmpty == nil) // 输出: nilNonEmpty == nil: true
}
使用接口的注意事项
虽然Go支持空接口，但是空接口interface{}在使用时应格外注意类型检查。如果我们的代码使用空接口匹配动态类型，虽然有很高的灵活性，但是编译器在编译阶段无法保证类型安全，我们需要在运行时进行类型检查来确保不会出现错误。因此应尽量避免使用可以"绕过"编译器类型安全检查的空接口类型。
Go标准库中对空接口类型的使用非常少，主要在以下两类中存在使用：
- 容器算法类：如container下的
heap、list和ring包，sort包和sync.Map等 - 格式化/日志类：例如
fmt、log
这些使用interface{}作为参数类型的函数或方法具备以下共同点：都是处理未知类型的数据。因此在这种情况下，使用具备"泛型"能力的interface{}类型都是可以理解的。随着Go支持泛型，许多场合下interface{}都可以被泛型所替代。