方法、嵌入和 iota,结构体上最容易记混的三件事

难度 ★★☆☆☆ · 前置:函数是一等值,闭包只是它的一个用法 | 一句话结论:方法接收者选值还是选指针,不只看要不要改数据,还要看它决定的方法集能不能满足某个接口。

先看 unsafe.Sizeof 打出来的三个数,Outer{} 是 32,Inner{} 是 16,(*Outer)(nil) 是 8。三个数摆在一起就有话说了,外层没有用指针指过去,它把内层那两个字段整个搬了进来,16 加 16 正好凑成 32,unsafe.Offsetof 也印证这一点,o.Inner 落在偏移 0,o.Name 落在偏移 16。

一个 string 头占 16 个字节,名字是空的也照样占着,零值不等于零字节。另一边是一个编译报错,原文长这样:.\main.go:10:16: cannot call pointer method Inc on Counter。这行来自 Counter{N: 1}.Inc(),一个自己写出来的字面量。传进去的是一份临时值,编译器想替它取地址也取不到,只好把这次调用判死。这两个现场并排放,结构体上那些说不清的地方就露出共同点了。方法写在值接收者上为什么也能通过指针调用,反过来却不行,取决于那个值站在哪块内存里。嵌入一个类型之后,外层的字段能直接点到,也是因为内层就长在外层这块内存里,中间没有隔着指针。

iota 换个写法从 1024 起步,是因为它在数行号,数的还是那个常量块里的行。

三个问题看着不像一家,问的却是同一件事,编译器手里有没有那块内存,以及它什么时候愿意替你取。

值接收者和指针接收者的分界

值接收者拿到的是接收者的副本,方法里怎么改都只改副本,外面一点动静都没有。指针接收者拿到的是地址,改的就是原来那份。这条规则简单到几乎不用记,可它偏偏不是选择接收者的唯一理由,甚至不是最重要的理由,因为绝大多数时候我们写指针接收者的动机是避免复制,一个结构体几百字节,每次调用都复制一遍不划算,这个理由比改数据更常见。

1
2
3
4
type Animal struct{ Name string }

func (a Animal) ValueHello() { a.Name = "改过的 " + a.Name }
func (a *Animal) PtrHello() { a.Name = "改过的 " + a.Name }

两条路都行得通,混着走最容易出事。

值被复制了。跑一遍就很清楚。a.ValueHello() 在方法里打印的是改过的名字,回到外面 a.Name 还是 cat;换成 a.PtrHello(),方法内和外面都是改过的名字。调用点的写法一模一样,都是 a.方法名(),编译器在背后自动做了取地址和复制这两件事,你不需要写 (&a).PtrHello(),也不需要写 (*p).ValueHello()。

这套自动转换几乎从不失败,失败的那一天你会看到一个 about pointer method 的报错,然后意识到自己踩在了可寻址性上。边界是编译器画的。编译器的体贴是有边界的,而这个边界就是后面那一节。

有一点常被忽略,值接收者里的修改并非毫无意义,它只是改不到调用方。

如果方法内部要构造一个修改后的副本再返回,值接收者反而是更自然的表达,调用方拿到的就是一个新值,谁都别想偷偷改别人的状态。标准库里的 time.Time 全是值接收者,Add 返回新的时间而不是改自己,这个设计让时间值可以随便传、随便存,不用担心谁在背后动了它。

反过来,sync.Mutex 的方法全是指针接收者,因为它维护的是锁的状态,复制一份锁毫无意义,还会制造出两把互不相干的锁。它只是副本。改不到外面,也是一种承诺。

选接收者还有一层现实考量,混杂的接收者会让类型的方法集变得难以描述。

同一种类型里有的方法能改、有的不能,使用者每次调用都要回头确认一遍,这种认知负担比复制那几个字节贵得多。

我的做法是一旦这个类型是可变状态,所有方法一律指针接收者,一个例外都不留。

反过来,如果这个类型天生不可变(比如坐标、金额、时间段),那就全用值接收者,让它能安全地被复制、被比较、被当作 map 的键。

嵌入不是继承,是字段提升

嵌入的语法是把类型名单独写一行,不写字段名,一行就够。写 type Outer struct { Inner } 之后,Outer 有一个叫 Inner 的字段,同时内层的所有字段和方法都被提升到外层,o.Name 能直接读到 Inner.Name,o.Who() 能直接调到 Inner.Who()。调用方看不出这个字段是外面一层还是里面一层,它就被当成外层的字段用。这种写法在标准库里有先例,bufio.ReadWriter 就是同时嵌入 *Reader 和 *Writer,两边的读写方法一并提升上来,用起来像一个完整对象。屏蔽的规则很直白,外层同名字段优先。Outer 自己有个 Name,那么 o.Name 拿到的是外层的 out,要读内层的那个必须写全路径 o.Inner.Name。方法同理,外层声明了同名方法,内层的就被挡住,只能显式写 o.Inner.Who() 才调得到。这一条在做接口实现的时候很实用,嵌入一个基础类型,再在外层覆盖其中一两个方法,剩下的自动继承,不用一个个转发。这种做法在测试替身里特别常见,真实类型嵌入一个桩,只改需要打桩的那几个方法。歧义比错误更烦。外层的赢,内层的等点名。嵌入还有一个副作用值得说清楚,被提升的方法,接收者是内层那个对象,不是外层。这意味着内层方法里对自身状态的修改,动的就是外层里嵌着的那份数据,外层不用做任何转发就生效了。

这个特性让嵌入看起来像在往外借能力,实际上是内层的字段刚好放在了外层里面,方法通过地址找过去,改的自然就是那一块。

我第一次意识到这一点,是在一个嵌入了 sync.Mutex 的结构体上,外层调 Lock 之后,同一个结构体的另一处 Unlock 也生效,因为它们锁的是同一块内存。

这种写法在标准库里很多,sync.WaitGroup 就经常被当作匿名字段嵌进别的结构体里用。

1
2
3
4
5
6
7
8
type Inner struct{ Name string }

func (i Inner) Who() string { return "inner:" + i.Name }

type Outer struct {
Inner
Name string
}

开头那几个数是我在本机 amd64 上量的,顺手用 GOARCH=386 又跑了一遍,Inner 变成 8,Outer 变成 16,对得上。再往外我就没跑了,arm64 那边我只交叉编译过,二进制在这台机器上起不来,所以那几个数对不对我没验证完。如果嵌入的两个类型有同名字段,情况就变成编译错误。Amb 同时嵌入 A 和 B,两者都有 V,写 amb.V 会得到 ambiguous selector amb.V。Go 不猜你想要哪个,它要求你写清楚 amb.A.V 或者 amb.B.V。这个设计跟方法集的处理是一致的,选择器歧义一律报错,一视同仁,不做隐式优先级,省掉了一整类难以发现的 bug。有些语言在这里会按声明顺序取第一个,读代码的人得回溯到类型定义才知道到底入了哪个,Go 选择让编译器替你问一句。歧义报错比猜对更省事。嵌入到这里就露出真面目了,它没有任何多态的语义,就是一次字段和方法的自动转发,转发完就结束。

Outer 不是 Inner 的子类型,不能把 Outer 传给要 Inner 的函数,也不能把 Outer 塞进 []Inner。想要那种关系,得定义接口。

这一点和继承的直觉冲突最大,很多人第一次用嵌入是为了复用,用着用着就把它当成了父类和子类,然后在函数签名上撞墙。

方法集决定谁能实现接口

先看形状。接口实现的判定不看字段,看方法集,也不看方法的名字,看的是签名和接收者。类型 T 的方法集包含所有值接收者方法,类型 *T 的方法集包含值接收者和指针接收者两种方法。

这个差别决定了 var g Getter = T{} 能不能编过。

这里打断一下自己,上面那句写得像两个并列的集合,其实是包含关系,*T 把 T 的那些方法全包了进去,多出来的只有指针接收者那部分。原因不复杂,如果允许 GCounter 的值满足接口,那么通过接口调 Get 时就得在一个副本上取地址,改了也没意义,语言干脆不允许。

它跟着类型走。

1
2
3
4
func (c *GCounter) Get() int { return c.N }

var g Getter = &GCounter{N: 3} // 可以
var g2 Getter = GCounter{N: 3} // 编译错误

反过来永远成立,*GCounter 既能满足指针接收者的接口,也能满足值接收者的接口,因为它解引用之后就是一个完整的 T,编译器随时能复制出来。

方法集也是形状。指针能顶值,值顶不了指针。这条规则最麻烦的地方是它引发的连锁反应。一个类型一旦有指针接收者方法,它就自动失去了值形态的接口满足能力,如果这个类型被塞进某个容器、某个回调参数,编译错误会出现在很远的地方,报的还是接口不匹配,看不出根子。

我那次重构就是这样,把三个值接收者改成指针之后,上游七八个文件一起红,报错说 *Foo does not implement Bar,而我改的明明是 Foo 的方法。

真正的原因是我某处把 Foo{} 直接传给了要 Bar 的地方,之前能过是因为方法集恰好覆盖,改成指针之后覆盖断了。所以接收者的选择要在类型设计阶段定下来,定完就一致。

同一个类型混着写值接收者和指针接收者,等于给使用者挖坑。值接收者的方法集里,为什么没有指针方法?

可寻址性:什么时候能调指针方法

取地址要许可。编译器会自动取地址,前提是这个值可寻址,这一点很关键。切片元素可寻址,数组元素可寻址,range 出来的循环变量在 Go 里也是可寻址的,for _, c := range cs { c.Inc() } 能编过,c.N 也确实变成了 2。变量、指针解引用、结构体字段这些都可寻址,因为它们背后都有一块确定的内存,编译器要取地址随时能取到。

同一个机制,两个坑。

不可寻址的三种情况最常见,报错原文里那句 about pointer method 多半就是它们的某一个。

不可寻址的东西 编译不过的写法 绕法
map 的元素 m["a"].Inc() 先把元素取出来、改完再写回去
复合字面量 Counter{N: 1}.Inc() 先赋给一个变量,再用变量调
接口里存的值 iface.Inc() 类型断言拿到具体的值,再调

遇到 about pointer method 的报错,先把这三条挨个试一遍。

这个坑我踩过两次。

不可寻址这件事有个反直觉的推论,range 的变量虽然可寻址,但它只是副本。

改它不会改到源切片(这一点在讲循环变量的时候已经踩过一次),结构体这里又踩一次。

类型定义和类型别名差一个符号

type Alias = Named 是别名,两者就是同一个类型,Named 上有的方法 Alias 全都有,连文档注释都共享,打印出来也一样。type Defined Named 是定义,创造了新类型,底层结构相同但方法集清零,原来那套方法一概没有,要自己重新写。跑出来 别名: Named:t、定义类型: Defined:t,两个值看起来一模一样,走的却是完全不同的方法。别名在调试和迁移里有用(比如把一个包里的类型搬到另一个包),中间用一层别名过渡,调用方的代码不用改,等你把调用方也迁完了再删掉别名。这个手法在大规模重构里救过我好几次,改动可以分两次提交,先搬定义,再搬调用方,中间那一天半的窗口期两边都能编。别名救过我一次。底层一样,语义不一样,这就是定义类型的全部价值。一个符号的事。

代价是转换要显式写,UserID(orderID) 这种转换合法但刺眼,刺眼正是它想要的效果,让人多看一眼这个跨语义的赋值到底该不该有。

定义类型还有个小福利,可以给它挂方法,UserID.Valid() 这种校验挂在类型上比挂在字符串上自然得多,调用点也更短。

1
2
3
4
type Alias = Named
type Defined Named

func (d Defined) String() string { return "Defined:" + d.Tag }

iota 是常量块里的行号

iota 只在 const 块里有意义,它从 0 开始,每多一行常量声明就自增 1,跳过的行也照样自增,_ 占位也算一行。const ( A = iota; B; C ) 得到 0 1 2,这里 B 和 C 没写表达式,会沿用上一行的 iota,只是 iota 的值变了。这个规则的关键在于沿用上一行和 iota 变值是两件独立的事,前者决定了表达式长什么样,后者决定了表达式算出来是多少。这一段得到 1024、1048576、1073741824。第一行用 _ 占位,作用就是让后面的 iota 从 1 开始。如果省掉那一行,KB 会从 1 开始,整个量级就错了,而且这种错不会有任何编译警告,只有等某个地方算出 1 字节的文件大小你才会发现。占位符不是摆设,它是偏移量,删掉那一行省下的只是一个字符,代价是整个量级。四个数各跑一遍,没取平均。iota 还有一个容易忽略的边界,它只在 const 声明里存在,换到 var 块里写 iota 会得到未定义的错误。这个限制决定了很多配置不能写成 iota 的形式,尤其是那些需要在运行时计算出来的常量表。我在做协议解析的时候想用 iota 给字段编号,写到一半发现编号要跟着版本号变,只能改成运行时构造的 map,注释里还得写清楚为什么没用 iota,免得后来的人又试一遍。

行号会被记住。

一个 const 块里可以有多个 iota 参与运算的常量,iota 的计数按行算,同一行里出现几次都是同一个值。

这个特性让位掩码写起来很顺,1 << iota 一行一个权限位,读的时候从上往下数就行。

iota 的坑基本都在跳行和占位上,写的时候心算一下第一行是第几行,能避掉九成的错。

1
2
3
4
5
6
const (
_ = iota
KB = 1 << (10 * iota)
MB
GB
)

一句总结

这三件事其实在回答同一个问题,值在 Go 里到底是怎么被对待的。接收者决定了方法是作用在副本上还是原件上,方法集把这个决定传递到了接口层面。

嵌入只是把字段和方法自动转发一层,转发的时候要处理同名冲突。

可寻址性决定了这套自动取地址的语法在哪些地方失效,失效的报错永远长得像另一回事。iota 稍微远一点,它关心的是常量块里的位置,跟结构体没关系,只是常和结构体一起出现在配置里。它一直在被复制。一个决定,往下传好几层。

写到这里我发现,Go 的很多坑其实是同一个坑的不同切面,都是值语义在起作用。

记住值被复制这件事,再记住哪几处编译器帮你省掉了复制,剩下的大部分语法现象都能推出来,不用背。

真要背的只有一句话,能不能改到外面,看的是你手里有没有那块内存。