接口:方法对得上就能装进去

难度 ★☆☆☆☆ · 前置:结构体与方法:Go 的对象就这么回事 | 一句话结论:接口只声明自己需要哪些方法,任何类型只要把这些方法长齐,就能装进接口变量,一个字都不用声明。

我学 Go 的第三周接了个小活,要算几种图形的面积。当时我从 Java 那边带过来一个习惯,先写一个父类,让圆和方块都继承它,父类里留一个空方法等着子类覆盖。结果我在 Go 里找不到 extends,也找不到 abstract,翻文档翻了半天只看到 interface 这个词,可它长得又不像类。我把 Shape 写出来,看着里面两行只有签名没有函数体,心里犯嘀咕,这玩意儿真能装东西吗。后来在一个同事的代码里看到 var s Shape = Sq{3} 这一行,没有 new,没有 implements,也没有任何一句声明说 Sq 是个 Shape,它就这么进去了。那天我才反应过来,Go 的接口不是一份需要申报的户口,是一张用来核对的清单,方法对上了就打勾。更别扭的是,我一开始还想给 Sq 加一个标记,写上它属于哪个形状,找了半天没找到地方放。Go 里根本没有这样一个位置,类型定义那里只有字段,方法只能写在外面,没有任何一格留给归属关系。归属是编译器算出来的,不是人填的,所以也没有填错这回事。

对上就打勾,对不上就编不过。

接口写的是一张方法清单

定义接口用的是 type 加 interface,花括号里一行一个方法签名。Shape 里面就两行,左边是方法名和参数,右边是返回值,行尾没有花括号,也没有函数体。

1
2
3
4
type Shape interface {
Area() float64
Name() string
}

这两行里没有一个字提到谁能实现它。接口不登记实现者,它只声明自己需要什么。谁想被当成 Shape 用,谁就得自己长出这两个方法,而且长出来的签名必须一模一样。

签名对上,才算对上。

三个类型的方法怎么对上接口,装进去之后接口变量里存了什么

名字差一个字母不算,参数多一个不算,返回值从 float64 换成 int 也不算。这类事情在别的地方顶多算个警告,在这里是硬邦邦的编译错误,一句解释都不给。好处是清单写在文件最上面,往下读代码的时候,只要扫一眼这个类型的方法列表,就知道它能不能对上,不用去别的地方查注册关系。维护老代码的时候这一点最省事,接口改了,对不上的地方一个都跑不掉,也不会漏掉某个角落里的实现。这套机制靠编译器一遍遍扫出来,不是靠人记住,所以它不会随时间烂掉。接口改一个方法名,全仓库里所有实现对不上的地方同时报错,改到一处不漏一处。要是在有 implements 关键字的地方,这种改动得靠查找引用顶着,漏了一处就等到运行时才炸,而 Go 把这件事压到了编译这一关。

接口本身是类型,这一点和 int、string 没有区别。它能当变量类型,能当函数参数,能当返回值,也能塞进切片当元素用。写业务代码的时候把它当成一个普通类型看就行,它占几个字节是编译器的事,跟你怎么用它没关系。

先把它当成一张清单。

没有 implements 这个词

拿方块开刀。定义 Sq 结构体,字段是边长,再加上两个方法,方法名、参数、返回值照着清单抄。接收者先都写成值,指针接收者的情况后面单独说。

1
2
3
4
5
6
type Sq struct {
Side float64
}

func (s Sq) Area() float64 { return s.Side * s.Side }
func (s Sq) Name() string { return "square" }

两个方法写完,我没有在任何地方写一句 Sq 实现了 Shape。Go 里也没有地方可写,你找不到 implements,找不到 extends,也找不到一张注册表。想把方块当成形状用,直接赋值,var s Shape = Sq{3},编译器在赋值那一刻现场比对,方法够就放行。这一步发生在编译期,运行时没有这一趟检查,所以不用担心赋值慢了半拍。反过来说,只要方法对得上,这个类型在哪个包里定义、是不是你写的、有没有文档,全都不影响它能不能装进去。标准库里的接口能被你自己的类型满足,靠的就是这一条。这种反过来的关系一开始让我很不习惯,接口不知道谁实现了它,实现它的类型也不提接口的名字。后来才明白好处在哪,接口可以后补,一段写好的类型,等有人需要某个清单的时候,它自己就符合了,不用回头去改类型定义。

打出来的第一行是 9,第二行是 square,第三行 %T 打的是 main.Sq。装进去的是方块,不是形状,Shape 这三个字一次都没露过面。

1
2
3
4
$ go run .
9
square
main.Sq

少一个方法就装不进去

现在故意搞一次破坏。把 Name 那个方法删掉,只留 Area,别的地方一个都不动,还是那句 var s Shape = Sq{3}。

1
2
3
4
5
type Sq struct {
Side float64
}

func (s Sq) Area() float64 { return s.Side * s.Side }

编译器报出来的这一句长得吓人,可该看的地方就三段。开头 .\main.go:15:16 是文件、行、列,行号正好是你写赋值那一行。中间说你把一个 Sq 结构体的值当成 Shape 使了,用在变量声明里。后面那句才是真正的原因,Sq does not implement Shape,括号里补了一刀,missing method Name,缺的是 Name 这个方法。不绕弯,直接点名缺谁,连去找的功夫都给你省了。

1
2
3
$ go run .
# missing
.\main.go:15:16: cannot use Sq{…} (value of struct type Sq) as Shape value in variable declaration: Sq does not implement Shape (missing method Name)

还有一种情况是方法在,但是长得不对。把 Name 的返回值从 string 改成 int,报错立刻换成另一句,底下多出两行 have 和 want,把两边并排放着给你看。

1
2
3
4
5
$ go run .
# wrongsig
.\main.go:16:16: cannot use Sq{…} (value of struct type Sq) as Shape value in variable declaration: Sq does not implement Shape (wrong type for method Name)
have Name() int
want Name() string

have 是你现在写的,want 是清单上要的。这两行前面缩进两个 Tab,中间没有别的字,就这么干巴巴地摆着,差别在哪里一眼就看得出来。参数个数不对的时候也是这个模板,have 后面会多出一个括号,want 那边还是空的。

几种说法其实是同一个模板,前半句永远是 Sq does not implement Shape,真正有用的信息全在括号里。

认括号里那半句就行。

括号里写的 意思 怎么改
missing method Name 根本没有这个方法 补一个方法上去
wrong type for method Name 方法在,签名不对 参数和返回值照清单改
method Area has pointer receiver 方法绑在指针上 改接收者,或者传地址

表格第三行那种情况,方法真的写了,只是写在了指针接收者上,赋值的时候传的又是值而不是地址,编译一样不过。

1
2
3
$ go run .
# ptrrecv
.\main.go:16:16: cannot use Sq{…} (value of struct type Sq) as Shape value in variable declaration: Sq does not implement Shape (method Area has pointer receiver)

这一条入门阶段先记住有这回事,等把方法集那一节补上再说。

一个函数,收两种形状

接口真正好用的地方在这里。写一个 Describe(s Shape) string,它只认 Shape 这张清单,里面调 s.Name() 和 s.Area()。传方块进去能算,传圆进去也能算,函数体一个字都不用改。以后往这个函数里塞第三种形状,只要它有两个方法,Describe 那一行不用动。反过来说,谁的方法少一个,连编译这一关都过不去,不会等到半夜在生产环境上才炸。这就是多态在 Go 里的全部内容,没有继承树,也没有虚函数表,只有一张清单,和一堆各自把方法长齐了的类型。你甚至不需要知道 Shape 有几个实现,加实现的时候也不用回头改 Shape 那个文件,两边的代码可以完全不认识对方,只要它们都认识那张清单。测试的时候塞一个假的进去,跑完再换回来,用的就是这一手。

1
2
3
4
5
6
7
8
func Describe(s Shape) string {
return fmt.Sprintf("%s 的面积是 %.2f", s.Name(), s.Area())
}

func main() {
fmt.Println(Describe(Sq{3}))
fmt.Println(Describe(Circle{2}))
}
1
2
3
$ go run .
square 的面积是 9.00
circle 的面积是 12.57

any 是空接口,什么都能装

有一个接口一个方法都不要求,它叫空接口,写出来是 interface{},Go 1.18 之后给了它一个别名 any,两个写法完全等价。清单是空的,所有类型都对得上,所以什么都能往里塞。打印的时候 %T 看类型,%v 看值,两个占位符一起用就能看清楚里面到底装了什么。标准库里到处是它,fmt.Println 的参数就写成了 ...any,你传多少个、传什么类型都行,靠的正是这一条。空接口不是万能工具,它把类型信息藏起来了,用的时候要一层层问回来。写库的时候参数收 any 很省事,用的人却要在自己那边写断言,麻烦只是换了个地方。所以标准库里像 sort.Slice 那样的签名,收 any 是有代价的设计,能写具体接口就别写空接口。

1
2
3
4
5
6
7
8
var x any = 42
fmt.Printf("%T %v\n", x, x)
x = "hello"
fmt.Printf("%T %v\n", x, x)
box := []any{42, "hello", true}
for _, v := range box {
fmt.Printf("%T %v\n", v, v)
}

同一个变量,前两行装整数,后两行装字符串,类型一路跟着变。x 的静态类型从头到尾都是 any,可里面装的东西一直在换,换的时候没有任何提示。

1
2
3
4
5
6
$ go run .
int 42
string hello
int 42
string hello
bool true

切片那三行更明显,一个 []any 里躺着整数、字符串、布尔,三种毫不相干的东西并排站着。数组和切片要求元素同类型,这里同的只是接口这一层,往下各是各的。

能装是能装,可装进去之后,能用的方法只剩清单上那几条,空清单上半条都没有,所以你连加都加不了。想用原来那个类型的功能,得先问一句里面到底是什么。

断言:问一次类型,拿一次值

想拿回原来的类型,得用类型断言,写法是 x.(T),问一句这个接口变量里装的是不是 T。带上 ok 的写法一次给两个结果,一个值,一个布尔,成功失败都不用中断程序。

1
2
3
4
5
6
7
var x any = 42
i, ok := x.(int)
fmt.Println(i, ok)
s, ok := x.(string)
fmt.Printf("%q %v\n", s, ok)
b, ok := x.(bool)
fmt.Println(b, ok)

三行的形状一模一样,结果全不一样。第一行拿回 42,ok 是 true。第二行问的是字符串,里面装的是整数,ok 变成 false,可变量还是有值,是个空字符串,用 %q 打出来是两对引号。第三行问布尔,同样 false,值是最没用的那个 false。

零值不是没有,是那一类的最小值。

不带 ok 的写法只有一半,v := x.(string),问不中直接崩。这不是吓唬人,程序停在那里,栈上只留下几行线索:第一行说 interface conversion,interface {} is int, not string,里面装的是整数,你要的是字符串。下面那几行是现场,从 main.main 开始,指着出事那一行的路径和行号,是 main.go 第 7 行。程序到这儿就停了,exit status 2,后面的代码一行都没跑。要命的是这种崩通常在线上才出现,本地那几条测试路径没走到,就一直看不见。

1
2
3
4
5
6
7
$ go run .
panic: interface conversion: interface {} is int, not string

goroutine 1 [running]:
main.main()
F:/Work/AI/Blog/_local/golab/h7/boom/main.go:7 +0x28
exit status 2

所以日常写代码,只要有一点点不确定,就用带 ok 的那一版。不确定才是常态,接口变量里装的是什么,往往是上一个函数决定的,你在这个函数里看不见。

两句写法,差一次崩溃。

断言的目标也可以是一个接口,x.(Shape) 问的是里面装的那东西满不满足 Shape。通过了就还你一个静态类型是 Shape 的值,可它里面装的还是原来那个具体类型,%T 打出来照样是 main.Sq,这一点最容易看岔。往窄里问也行,写成 x.(interface{ Area() float64 }),只要方法够就通过,不用为了问一次专门定义个接口。这一趟会重做一次方法比对,跟赋值那一次是一回事,只不过方向反过来。

type switch:一次问一串

要连着问好几个类型,用 if 一层层套太丑。Go 给了个专门的写法,switch v := x.(type),注意括号里是 type 不是某个具体类型,它只能长在 switch 头上。每个 case 写一个类型,匹配上的那个分支里,v 已经是那个类型了,不用再断言一次。

1
2
3
4
5
6
7
8
9
10
11
12
func Show(x any) {
switch v := x.(type) {
case int:
fmt.Println("int", v)
case string:
fmt.Println("string", v)
case bool:
fmt.Println("bool", v)
default:
fmt.Printf("default %T\n", v)
}
}

拿四种东西喂进去,整数、字符串、布尔,外加一个浮点数。前三个各走各的分支,浮点数没有自己的坑位,落进 default,第四行就是它打的,%T 说的是 float64。没写 case 的类型不会凭空消失,它照样进得来,只是在 switch 里没地方去,被兜底接住了。这也是 default 值得写的原因,可以借它打一行日志,看看线上到底还有哪些类型在往里塞。

1
2
3
4
5
$ go run .
int 42
string hi
bool true
default float64

每个分支里的 v 类型都不一样,int 那个分支里能直接做加法,string 那个分支里能直接取长度,编译器早就替你换好了,不用再写一遍断言。写起来比一串 if 干净,而且漏了某个类型的时候,default 那一眼就能看出来现在还收着哪些意料之外的东西。

接口可以拼起来

接口能嵌接口。标准库里最常用的两个是 io.Reader 和 io.Writer,一个只有 Read(p []byte) (int, error),一个只有 Write(p []byte) (int, error)。把它们嵌进一个新的接口,新清单就是这两个方法,谁长齐了谁进得来。

1
2
3
4
type ReadWriter interface {
io.Reader
io.Writer
}

写一个 Buf,两个方法都实现,用指针接收者。它能装进 ReadWriter,也能单独装进 io.Reader 或者 io.Writer,装进哪一个,外面能看见的就只有那一个的方法。第 2 行读回来 5 个字节,第 3 行写进去 2 个,剩下两行 %T 打出来都是 *main.Buf,说明装进不同接口的确实是同一个东西。这也是标准库里的函数参数写得那么窄的原因,一个函数只要读,就只要求 io.Reader,你能传的东西就多得多,文件、网络连接、字符串缓冲,全都能进。这种拼法在标准库里到处都是,os.File 同时满足 io.Reader、io.Writer 和 io.Closer,一个类型能进好几个接口,装进哪个由你当场决定。接口拆得细,能接住的东西就多,需要几个就拼几个,这也是标准库里的接口普遍只有一个方法的原因。

1
2
3
4
5
6
$ go run .
4 <nil>
5 <nil> hello
2 <nil> hi
*main.Buf
*main.Buf

组合接口也不是白拼的,让一个只有 Write 的 Sink 去装 ReadWriter,编译直接不过,缺的那个方法是从 io.Reader 带过来的。

1
2
3
$ go run .
# rwmiss
.\main.go:20:22: cannot use &Sink{} (value of type *Sink) as ReadWriter value in variable declaration: *Sink does not implement ReadWriter (missing method Read)

标准库里还有一堆这样的小接口,fmt.Stringer 只有一个 String() string,自己给某个类型写上这个方法,fmt.Println 打它的时候就会改用 String() 的结果,不用你手动调。

下一篇换一个方向,讲错误怎么当一个普通的返回值往回传。