接口

// 一个非定义接口类型。
interface {
    About() string
}

// ReadWriter是一个定义的接口类型。
type ReadWriter interface {
    Read(buf []byte) (n int, err error)
    Write(buf []byte) (n int, err error)
}
// Runnable是一个非定义接口类型的别名。
type Runnable = interface {
    Run()
}

请注意ReadWriter接口类型中指定的方法原型都有一个error类型的返回值。
error类型为一个内置接口类型。
它的定义声明如下：

type error interface {
        Error() string
}

特别地，一个没有指定任何方法原型的接口类型称为一个空接口类型。
下面是两个空接口类型：

// 一个非定义空接口类型。
interface{}

// 类型I是一个定义的空接口类型。
type I interface{}

• 对于一个非接口类型，它的方法集由所有为它声明的（包括显式和隐式的）方法的原型组成。
• 对于一个接口类型，它的方法集就是它所指定的方法集。

type Book struct {
    name string
    // 更多其它字段……
}

func (book *Book) About() string {
    return “Book: “ + book.name
}
type MyInt int

func (MyInt) About() string {
    return “我是一个自定义整数类型”
}

注意：因为任何方法集都是一个空方法集的超集，所以任何类型都实现了任何空接口类型。 这是Go中的一个重要事实。

隐式实现关系的设计使得一个声明在另一个代码包（包括标准库包）中的类型可以被动地实现一个用户代码包中的接口类型。
比如，如果我们声明一个像下面这样的接口类型，则database/sql标准库包中声明的DB和Tx类型都实现了这个接口类型，因为它们都拥有此接口类型指定的三个方法。

import "database/sql"

...

type DatabaseStorer interface {
    Exec(query string, args ...interface{}) (sql.Result, error)
    Prepare(query string) (*sql.Stmt, error)
    Query(query string, args ...interface{}) (*sql.Rows, error)
}

每个接口值都可以看作是一个用来包裹一个非接口值的盒子。 欲将一个非接口值包裹在一个接口值中，此非接口值的类型必须实现了此接口值的类型。

在Go中，如果类型T实现了一个接口类型I，则类型T的值都可以隐式转换到类型I。
换句话说，类型T的值可以赋给类型I的可修改值。
当一个T值被转换到类型I（或者赋给一个I值）的时候，

• 如果类型T是一个非接口类型，则此T值的一个复制将被包裹在结果（或者目标）I值中。 此操作的时间复杂度为O(n)，其中n为T值的尺寸。
• 如果类型T也为一个接口类型，则此T值中当前包裹的（非接口）值将被复制一份到结果（或者目标）I值中。 官方标准编译器为此操作做了优化，使得此操作的时间复杂度为O(1)，而不是O(n)。

包裹在一个接口值中的非接口值的类型信息也和此接口值一起被包裹在此接口值中（见下面详解）。

当一个非接口值被包裹在一个接口值中，此非接口值称为此接口值的动态值，此非接口值的类型称为此接口值的动态类型。

接口值的动态值的直接部分是不可修改的，除非它的动态值被整体替换为另一个动态值。

接口类型的零值也用预声明的nil标识符来表示。 一个nil接口值中什么也没包裹。将一个接口值修改为nil将清空包裹在此接口值中的非接口值。

（注意，在Go中，很多其它非接口类型的零值也使用nil标识符来表示。 非接口类型的nil零值也可以被包裹在接口值中。 一个包裹了一个nil非接口值的接口值不是一个nil接口值，因为它并非什么都没包裹。）

因为任何类型都实现了空接口类型，所以任何非接口值都可以被包裹在任何一个空接口类型的接口值中。 （以后，一个空接口类型的接口值将被称为一个空接口值。注意空接口值和nil接口值是两个不同的概念。） 因为这个原因，空接口值可以被认为是很多其它语言中的any类型。

当一个类型不确定值（除了类型不确定的nil）被转换为一个空接口类型（或者赋给一个空接口值），此类型不确定值将首先转换为它的默认类型。 （或者说，此类型不确定值将被推断为一个它的默认类型的类型确定值。）

下面这个例子展示了一些目标值为接口类型的赋值。

package main

import "fmt"

type Aboutable interface {
    About() string
}

// 类型*Book实现了接口类型Aboutable。
type Book struct {
    name string
}
func (book *Book) About() string {
    return "Book: " + book.name
}

func main() {
    // 一个*Book值被包裹在了一个Aboutable值中。
    var a Aboutable = &Book{"Go语言101"}
    fmt.Println(a) // &{Go语言101}

    // i是一个空接口值。类型*Book实现了任何空接口类型。
    var i interface{} = &Book{"Rust 101"}
    fmt.Println(i) // &{Rust 101}

    // Aboutable实现了空接口类型interface{}。
    i = a
    fmt.Println(i) // &{Go语言101}
}

请注意，在之前的文章中多次使用过的fmt.Println函数的原型为：

func Println(a ...interface{}) (n int, err error)

这解释了为什么任何类型的实参都可以使用在fmt.Println函数调用中。

下面是另一个展示了一个空接口类型的值包裹着各种非接口值的例子：

package main

import "fmt"

func main() {
    var i interface{}
    i = []int{1, 2, 3}
    fmt.Println(i) // [1 2 3]
    i = map[string]int{"Go": 2012}
    fmt.Println(i) // map[Go:2012]
    i = true
    fmt.Println(i) // true
    i = 1
    fmt.Println(i) // 1
    i = "abc"
    fmt.Println(i) // abc

    // 将接口值i中包裹的值清除掉。
    i = nil
    fmt.Println(i) // <nil>
}

在编译时刻，Go编译器将构建一个全局表用来存储代码中要用到的各个类型的信息。 对于一个类型来说，这些信息包括：此类型的种类（kind）、此类型的所有方法和字段信息、此类型的尺寸，等等。 这个全局表将在程序启动的时候被加载到内存中。

在运行时刻，当一个非接口值被包裹到一个接口值，Go运行时（至少对于官方标准运行时来说）将分析和构建这两个值的类型的实现关系信息，并将此实现关系信息存入到此接口值内。 对每一对这样的类型，它们的实现关系信息将仅被最多构建一次。并且为了程序效率考虑，此实现关系信息将被缓存在内存中的一个全局映射中，以备后用。 所以此全局映射中的条目数永不减少。 事实上，一个非零接口值在内部只是使用一个指针字段来引用着此全局映射中的一个实现关系信息条目。

对于一个非接口类型和接口类型对，它们的实现关系信息包括两部分的内容：

1. 动态类型（即此非接口类型）的信息。
2. 一个方法表（切片类型），其中存储了所有此接口类型指定的并且为此非接口类型（动态类型）声明的方法。

这两部分的内容对于实现Go中的两个特性起着至关重要的作用。

1. 动态类型信息是实现反射的关键。
2. 方法表是实现多态（见下一节）的关键。

package main

import “fmt”
type Filter interface {
    About() string
    Process([]int) []int
}
// UniqueFilter用来删除重复的数字。
type UniqueFilter struct{}
func (UniqueFilter) About() string {
    return “删除重复的数字”
}
func (UniqueFilter) Process(inputs []int) []int {
    outs := make([]int, 0, len(inputs))
    pusheds := make(map[int]bool)
    for _, n := range inputs {
        if !pusheds[n] {
            pusheds[n] = true
            outs = append(outs, n)
        }
    }
    return outs
}
// MultipleFilter用来只保留某个整数的倍数数字。
type MultipleFilter int
func (mf MultipleFilter) About() string {
    return fmt.Sprintf(“保留%v的倍数”, mf)
}
func (mf MultipleFilter) Process(inputs []int) []int {
    var outs = make([]int, 0, len(inputs))
    for _, n := range inputs {
        if n % int(mf) == 0 {
            outs = append(outs, n)
        }
    }
    return outs
}
// 在多态特性的帮助下，只需要一个filteAndPrint函数。
func filteAndPrint(fltr Filter, unfiltered []int) []int {
    // 在fltr参数上调用方法其实是调用fltr的动态值的方法。
    filtered := fltr.Process(unfiltered)
    fmt.Println(fltr.About() + “:\n\t”, filtered)
    return filtered
}
func main() {
    numbers := []int{12, 7, 21, 12, 12, 26, 25, 21, 30}
    fmt.Println(“过滤之前：\n\t”, numbers)
// 三个非接口值被包裹在一个Filter切片
// 的三个接口元素中。
filters := []Filter{
    UniqueFilter{},
    MultipleFilter(2),
    MultipleFilter(3),
}

// 每个切片元素将被赋值给类型为Filter的
// 循环变量fltr。每个元素中的动态值也将
// 被同时复制并被包裹在循环变量fltr中。
for _, fltr := range filters {
    numbers = filteAndPrint(fltr, numbers)
}
}

输出结果：

过滤之前：
     [12 7 21 12 12 26 25 21 30]
删除重复的数字:
     [12 7 21 26 25 30]
保留2的倍数:
     [12 26 30]
保留3的倍数:
     [12 30]

在上面这个例子中，多态使得我们不必为每个过滤器类型写一个单独的filteAndPrint函数。

除了上述这个好处，多态也使得一个代码包的开发者可以在此代码包中声明一个接口类型并声明一个拥有此接口类型参数的函数（或者方法），从而此代码包的一个用户可以在用户包中声明一个实现了此接口类型的用户类型，并且将此用户类型的值做为实参传递给此代码包中声明的函数（或者方法）的调用。 此代码包的开发者并不用关心一个用户类型具体是如何声明的，只要此用户类型满足此代码包中声明的接口类型规定的行为即可。

1. 将一个非接口值转换为一个接口类型。在这样的转换中，此非接口值的类型必须实现了此接口类型。
2. 将一个接口值转换为另一个接口类型（前者接口值的类型实现了后者目标接口类型）。
3. 将一个接口值转换为一个非接口类型（此非接口类型必须实现了此接口值的接口类型）。
4. 将一个接口值转换为另一个接口类型（前者接口值的类型未实现后者目标接口类型，但是前者的动态类型有可能实现了目标接口类型）。

前两种情形已经在前面几节中介绍过了。这两种情形都要求源值的类型必须实现了目标接口类型。 它们都是通过普通类型转换（无论是隐式的还是显式的）来达成的。这两种情形的合法性是在编译时刻验证的。

本节将介绍后两种情形。这两种情形的合法性是在运行时刻通过类型断言来验证的。 事实上，类型断言也适用于上面列出的第二种情形。

一个类型断言表达式的语法为i.(T)，其中i为一个接口值，T为一个类型名或者类型字面表示。
类型T可以为

• 任意一个非接口类型。
• 或者一个任意接口类型。

在一个类型断言表达式i.(T)中，i称为断言值，T称为断言类型。
一个断言可能成功或者失败。

• 对于T是一个非接口类型的情况，如果断言值i的动态类型存在并且此动态类型和T为同一类型，则此断言将成功；否则，此断言失败。 当此断言成功时，此类型断言表达式的估值结果为断言值i的动态值的一个复制。 我们可以把此种情况看作是一次拆封动态值的尝试。
• 对于T是一个接口类型的情况，当断言值i的动态类型存在并且此动态类型实现了接口类型T，则此断言将成功；否则，此断言失败。 当此断言成功时，此类型断言表达式的估值结果为一个包裹了断言值i的动态值的一个复制的T值。

一个失败的类型断言的估值结果为断言类型的零值。

按照上述规则，如果一个类型断言中的断言值是一个零值nil接口值，则此断言必定失败。

对于大多数场合，一个类型断言被用做一个单值表达式。 但是，当一个类型断言被用做一个赋值语句中的唯一源值时，此断言可以返回一个可选的第二个结果并被视作为一个多值表达式。 此可选的第二个结果为一个类型不确定的布尔值，用来表示此断言是否成功了。

注意：如果一个断言失败并且它的可选的第二个结果未呈现，则此断言将造成一个恐慌。

一个展示了如何使用类型断言的例子（断言类型为非接口类型）：

package main

import "fmt"

func main() {
    // 编译器将把123的类型推断为内置类型int。
    var x interface{} = 123

    // 情形一：
    n, ok := x.(int)
    fmt.Println(n, ok) // 123 true
    n = x.(int)
    fmt.Println(n) // 123

    // 情形二：
    a, ok := x.(float64)
    fmt.Println(a, ok) // 0 false

    // 情形三：
    a = x.(float64) // 将产生一个恐慌
}

另一个展示了如何使用类型断言的例子（断言类型为接口类型）：

package main

import "fmt"

type Writer interface {
    Write(buf []byte) (int, error)
}

type DummyWriter struct{}
func (DummyWriter) Write(buf []byte) (int, error) {
    return len(buf), nil
}

func main() {
    var x interface{} = DummyWriter{}
    // y的动态类型为内置类型string。
    var y interface{} = "abc"
    var w Writer
    var ok bool

    // DummyWriter既实现了Writer，也实现了interface{}。
    w, ok = x.(Writer)
    fmt.Println(w, ok) // {} true
    x, ok = w.(interface{})
    fmt.Println(x, ok) // {} true

    // y的动态类型为string。string类型并没有实现Writer。
    w, ok = y.(Writer)
    fmt.Println(w, ok) // <nil> false
    w = y.(Writer)     // 将产生一个恐慌
}

事实上，对于一个动态类型为T的接口值i，方法调用i.m(...)等价于i.(T).m(...)。

switch aSimpleStatement; v := x.(type) {
case TypeA:
    ...
case TypeB, TypeC:
    ...
case nil:
    ...
default:
    ...
}

其中aSimpleStatement;部分是可选的。 aSimpleStatement必须是一个简单语句。 x必须为一个估值结果为接口值的表达式，它称为此代码块中的断言值。 v称为此代码块中的断言结果，它必须出现在一个短变量声明形式中。

在一个type-switch代码块中，每个case关键字后可以跟随一个nil标识符和若干个类型名或类型字面表示形式。 在同一个type-switch代码块中，这些跟随在所有case关键字后的条目不可重复。

如果跟随在某个case关键字后的条目为一个非接口类型（用一个类型名或类型字面表示），则此非接口类型必须实现了断言值x的（接口）类型。

下面是一个使用了type-switch代码块的例子：

package main

import "fmt"

func main() {
    values := []interface{}{
        456, "abc", true, 0.33, int32(789),
        []int{1, 2, 3}, map[int]bool{}, nil,
    }
    for _, x := range values {
        // 这里，虽然变量v只被声明了一次，但是它在
        // 不同分支中可以表现为多个类型的变量值。
        switch v := x.(type) {
        case []int: // 一个类型字面表示
            // 在此分支中，v的类型为[]int。
            fmt.Println("int slice:", v)
        case string: // 一个类型名
            // 在此分支中，v的类型为string。
            fmt.Println("string:", v)
        case int, float64, int32: // 多个类型名
            // 在此分支中，v的类型为x的类型interface{}。
            fmt.Println("number:", v)
        case nil:
            // 在此分支中，v的类型为x的类型interface{}。
            fmt.Println(v)
        default:
            // 在此分支中，v的类型为x的类型interface{}。
            fmt.Println("others:", v)
        }
        // 注意：在最后的三个分支中，v均为接口值x的一个复制。
    }
}

输出结果：

number: 456
string: abc
others: true
number: 0.33
number: 789
int slice: [1 2 3]
others: map[]
<nil>

上面这个例子程序在逻辑上等价于下面这个：

package main

import "fmt"

func main() {
    values := []interface{}{
        456, "abc", true, 0.33, int32(789),
        []int{1, 2, 3}, map[int]bool{}, nil,
    }
    for _, x := range values {
        if v, ok := x.([]int); ok {
            fmt.Println("int slice:", v)
        } else if v, ok := x.(string); ok {
            fmt.Println("string:", v)
        } else if x == nil {
            v := x
            fmt.Println(v)
        } else {
            _, isInt := x.(int)
            _, isFloat64 := x.(float64)
            _, isInt32 := x.(int32)
            if isInt || isFloat64 || isInt32 {
                v := x
                fmt.Println("number:", v)
            } else {
                v := x
                fmt.Println("others:", v)
            }
        }
    }
}

如果我们不关心一个type-switch代码块中的断言结果，则此type-switch代码块可简写为switch x.(type) {...}。

type-switch代码块和switch-case代码块有很多共同点：

• 在一个type-switch代码块中，最多只能有一个default分支存在。
• 在一个type-switch代码块中，如果default分支存在，它可以为最后一个分支、第一个分支或者中间的某个分支。
• 一个type-switch代码块可以不包含任何分支，它可以被视为一个空操作。

但是，和switch-case代码块不一样，fallthrough语句不能使用在type-switch代码块中。

type Ia interface {
    fa()
}

type Ib = interface {
    fb()
}

type Ic interface {
    fa()
    fb()
}

type Id = interface {
    Ia // 内嵌Ia
    Ib // 内嵌Ib
}

type Ie interface {
    Ia // 内嵌Ia
    fb()
}

在Go 1.14版本之前，如果两个接口类型都指定了一个同名方法，则这两个接口类型不可被同时被内嵌在同一个接口类型中，即使它们指定的同名方法的原型也一致。
比如，下面的代码中的几个接口类型声明在Go 1.14版本之前都是均是非法的。

type Ix interface {
    Ia
    Ic
}

type Iy = interface {
    Ib
    Ic
}

type Iz interface {
    Ic
    fa()
}

从Go 1.14版本开始，上面这段代码中的几个接口类型声明均被认为是合法的，它们指定的方法集其实和Ic是一样的。

一个接口类型不能内嵌（无论是直接还是间接）它自己。

1. 比较一个非接口值和接口值；
2. 比较两个接口值。

对于第一种情形，非接口值的类型必须实现了接口值的类型（假设此接口类型为I），所以此非接口值可以被隐式转化为（包裹到）一个I值中。 这意味着非接口值和接口值的比较可以转化为两个接口值的比较。所以下面我们只探讨两个接口值比较的情形。

比较两个接口值其实是比较这两个接口值的动态类型和和动态值。

下面是（使用==比较运算符）比较两个接口值的步骤：

1. 如果其中一个接口值是一个nil接口值，则比较结果为另一个接口值是否也为一个nil接口值。
2. 如果这两个接口值的动态类型不一样，则比较结果为false。
3. 对于这两个接口值的动态类型一样的情形，
   • 如果它们的动态类型为一个不可比较类型，则将产生一个恐慌。
   • 否则，比较结果为它们的动态值的比较结果。

简而言之，两个接口值的比较结果只有在下面两种任一情况下才为true：

1. 这两个接口值都为nil接口值。
2. 这两个接口值的动态类型相同、动态类型为可比较类型、并且动态值相等。

根据此规则，两个包裹了不同非接口类型的nil零值的接口值是不相等的。
一个例子：

package main

import "fmt"

func main() {
    var a, b, c interface{} = "abc", 123, "a"+"b"+"c"
    fmt.Println(a == b) // 第二步的情形。输出"false"。
    fmt.Println(a == c) // 第三步的情形。输出"true"。

    var x *int = nil
    var y *bool = nil
    var ix, iy interface{} = x, y
    var i interface{} = nil
    fmt.Println(ix == iy) // 第二步的情形。输出"false"。
    fmt.Println(ix == i)  // 第一步的情形。输出"false"。
    fmt.Println(iy == i)  // 第一步的情形。输出"false"。

    var s []int = nil // []int为一个不可比较类型。
    i = s
    fmt.Println(i == nil) // 第一步的情形。输出"false"。
    fmt.Println(i == i)   // 第三步的情形。将产生一个恐慌。
}

package main

import “fmt”
func main() {
    words := []string{
        “Go”, “is”, “a”, “high”,
        “efficient”, “language.”,
    }
// fmt.Println函数的原型为：
// func Println(a ...interface{}) (n int, err error)
// 所以words...不能传递给此函数的调用。

// fmt.Println(words...) // 编译不通过

// 将[]string值转换为类型[]interface{}。
iw := make([]interface{}, 0, len(words))
for _, w := range words {
    iw = append(iw, w)
}
fmt.Println(iw...) // 编译没问题
}

如果接口类型I指定了一个名为m的方法原型，则编译器将隐式声明一个与之对应的函数名为I.m的函数。 此函数比m的方法原型中的参数多一个。此多出来的参数为函数I.m的第一个参数，它的类型为I。 对于一个类型为I的值i，方法调用i.m(...)和函数调用I.m(i, ...)是等价的。

一个例子：

package main

import "fmt"

type I interface {
    m(int)bool
}

type T string
func (t T) m(n int) bool {
    return len(t) > n
}

func main() {
    var i I = T("gopher")
    fmt.Println(i.m(5))                          // true
    fmt.Println(I.m(i, 5))                       // true
    fmt.Println(interface {m(int) bool}.m(i, 5)) // true

    // 下面这几行被执行的时候都将会产生一个恐慌。
    I(nil).m(5)
    I.m(nil, 5)
    interface {m(int) bool}.m(nil, 5)
}