golang拾遗:自定义类型和方法集

打印 上一主题 下一主题

主题 871|帖子 871|积分 2613

golang拾遗主要是用来记录一些遗忘了的、平时从没注意过的golang相关知识。
很久没更新了,我们先以一个谜题开头练练手:
  1. package main
  2. import (
  3.     "encoding/json"
  4.     "fmt"
  5.     "time"
  6. )
  7. type MyTime time.Time
  8. func main() {
  9.     myTime := MyTime(time.Now()) // 假设获得的时间是 2022年7月20日20:30:00,时区UTC+8
  10.     res, err := json.Marshal(myTime)
  11.     if err != nil {
  12.         panic(err)
  13.     }
  14.     fmt.Println(string(res))
  15. }
复制代码
请问上述代码会输出什么:

  • 编译错误
  • 运行时panic
  • {}
  • "2022-07-20T20:30:00.135693011+08:00"
很多人一定会选4吧,然而答案是3:
  1. $ go run customize.go
  2. {}
复制代码
是不是很意外,MyTime就是time.Time,理论上应该也实现了json.Marshaler,为什么输出的是空的呢?
实际上这是最近某个群友遇到的问题,乍一看像是golang的bug,但其实还是没掌握语言的基本规则。
在深入下去之前,我们先问自己两个问题:

  • MyTime 真的是 Time 类型吗?
  • MyTime 真的实现了 json.Marshaler 吗?
对于问题1,只需要引用spec里的说明即可:
A named type is always different from any other type.
https://go.dev/ref/spec#Type_identity
意思是说,只要是type定义出来的类型,都是不同的(type alias除外),即使他们的underlying type是一样的,也是两个不同的类型。
那么问题1的答案就知道了,显然MyTime不是time.Time。
既然MyTime不是Time,那它是否能用Time类型的method呢?毕竟MyTime的基底类型是Time呀。我们写段代码验证下:
  1. package main
  2. import (
  3.     "fmt"
  4.     "time"
  5. )
  6. type MyTime time.Time
  7. func main() {
  8.     myTime := MyTime(time.Now()) // 假设获得的时间是 2022年7月20日20:30:00,时区UTC+8
  9.     res, err := myTime.MarsharlJSON()
  10.     if err != nil {
  11.             panic(err)
  12.     }
  13.     fmt.Println(string(res))
  14. }
复制代码
运行结果:
  1. # command-line-arguments
  2. ./checkoutit.go:12:24: myTime.MarsharlJSON undefined (type MyTime has no field or method MarsharlJSON)
复制代码
现在问题2也有答案了:MyTime没有实现json.Marshaler。
那么对于一个没有实现json.Marshaler的类型,json是怎么序列化的呢?这里就不卖关子了,文档里有写,对于没实现Marshaler的类型,默认的流程使用反射获取所有非export的字段,然后依次序列化,我们再看看time的结构:
  1. type Time struct {
  2.         // wall and ext encode the wall time seconds, wall time nanoseconds,
  3.         // and optional monotonic clock reading in nanoseconds.
  4.         //
  5.         // From high to low bit position, wall encodes a 1-bit flag (hasMonotonic),
  6.         // a 33-bit seconds field, and a 30-bit wall time nanoseconds field.
  7.         // The nanoseconds field is in the range [0, 999999999].
  8.         // If the hasMonotonic bit is 0, then the 33-bit field must be zero
  9.         // and the full signed 64-bit wall seconds since Jan 1 year 1 is stored in ext.
  10.         // If the hasMonotonic bit is 1, then the 33-bit field holds a 33-bit
  11.         // unsigned wall seconds since Jan 1 year 1885, and ext holds a
  12.         // signed 64-bit monotonic clock reading, nanoseconds since process start.
  13.         wall uint64
  14.         ext  int64
  15.         // loc specifies the Location that should be used to
  16.         // determine the minute, hour, month, day, and year
  17.         // that correspond to this Time.
  18.         // The nil location means UTC.
  19.         // All UTC times are represented with loc==nil, never loc==&utcLoc.
  20.         loc *Location
  21. }
复制代码
里面都是非公开字段,所以直接序列化后整个结果就是{}。当然,Time类型自己重新实现了json.Marshaler,所以可以正常序列化成我们期望的值。
而我们的MyTime没有实现整个接口,所以走了默认的序列化流程。
所以我们可以得出一个重要的结论:从某个类型A派生出的类型B,B并不能获得A的方法集中的任何一个
想要B拥有A的所有方法也不是不行,但得和type B A这样的形式说再见了。
方法一是使用type alias:
  1. - type MyTime time.Time
  2. + type MyTime = time.Time
  3. func main() {
  4. -   myTime := MyTime(time.Now()) // 假设获得的时间是 2022年7月20日20:30:00,时区UTC+8
  5. +   var myTime MyTime = time.Now() // 假设获得的时间是 2022年7月20日20:30:00,时区UTC+8
  6.     res, err := json.Marshal(myTime)
  7.     if err != nil {
  8.         panic(err)
  9.     }
  10.     fmt.Println(string(res))
  11. }
复制代码
类型别名自如其名,就是创建了一个类型A的别名而没有定义任何新类型(注意那两行改动)。现在MyTime就是Time了,自然也可以直接利用Time的MarshalJSON。
方法二,使用内嵌类型:
  1. - type MyTime time.Time
  2. + type MyTime struct {
  3. +     time.Time
  4. + }
  5. func main() {
  6. -   myTime := MyTime(time.Now()) // 假设获得的时间是 2022年7月20日20:30:00,时区UTC+8
  7. +   myTime := MyTime{time.Now}
  8.     res, err := myTime.MarsharlJSON()
  9.     if err != nil {
  10.             panic(err)
  11.     }
  12.     fmt.Println(string(res))
  13. }
复制代码
通过将Time嵌入MyTime,MyTime也可以获得Time类型的方法集。更具体的可以看我之前写的另一篇文章:golang拾遗:嵌入类型
如果我实在需要派生出一种新的类型呢,通常在我们写一个通用模块的时候需要隐藏实现的细节,所以想要对原始类型进行一定的包装,这时该怎么办呢?
实际上我们可以让MyTime重新实现json.Marshaler:
  1. type MyTime time.Time
  2. func (m MyTime) MarshalJSON() ([]byte, error) {
  3.     // 我图方便就直接复用Time的了
  4.     return time.Time(m).MarshalJSON()
  5. }
  6. func main() {
  7.     myTime := MyTime(time.Now()) // 假设获得的时间是 2022年7月20日20:30:00,时区UTC+8
  8.     res, err := myTime.MarsharlJSON()
  9.     if err != nil {
  10.             panic(err)
  11.     }
  12.     fmt.Println(string(res))
  13. }
复制代码
这么做看上去违反了DRY原则,其实未必,这里只是示例写的烂而已,真实场景下往往对派生出来的自定义类型进行一些定制,因此序列化函数里会有额外的一些操作,这样就和DRY不冲突了。
不管哪一种方案,都可以解决问题,根据自己的实际需求做选择即可。
总结

总结一下,一个派生自A的自定义类型B,它的方法集中的方法只有两个来源:

  • 直接定义在B上的那些方法
  • 作为嵌入类型包含在B里的其他类型的方法
而A的方法是不存在在B中的。
如果是从一个匿名类型派生的自定义类型B(type B struct {a, b int}),那么B的方法集中的方法只有一个来源:

  • 直接定义在B上的那些方法
还有最重要的,如果两个类型名字不同,即使它们的结构完全相同,也是两个不同的类型
这些边边角角的知识很容易被遗忘,但还是有机会在工作中遇到的,记牢了可以省很多事。

免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!
回复

使用道具 举报

0 个回复

倒序浏览

快速回复

您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

没腿的鸟

金牌会员
这个人很懒什么都没写!

标签云

快速回复 返回顶部 返回列表