Loading...
墨滴

楼仔

2021/05/04  阅读:20  主题:默认主题

Go系列教程4 - 结构体&方法

匿名字段

所谓匿名字段,是指没有名字,仅有类型的字段,被称为嵌入字段或者嵌入类型。

type attr struct{
    perm int
}
type file struct{
    name string
    attr // 仅有类名
}
var f file
f.name = "lvmenglou"
f.perm = 24 // 等价于f.attr.perm = 24

方法覆盖

方法存在同名遮蔽问题,通过匿名字段user构建manager结构,两者都实现了toString()方法,对于变量m调用toString()方法时,会直接屏蔽掉user.toString()方法,实现覆盖操作;但是也可以通过m.user.toString()直接访问的user的toString()方法。

type user struct{}
type manager struct{
    user // 匿名字段
}
func (user) toString() string{
    return "user"
}
func (m manager) toString() string{
    return m.user.toString() + ";manager"
}
func main(){
    var m manager
    println(m.toString())      // 输出:user;manager
    println(m.user.toString()) // 输出:user
}

值方法和指针方法

当你给某个struct定制一个字符串转换方法,可能会纠结选择value methods还是pointer methods方式:

func (ms MyStruct) String() string  // value methods
func (ms *MyStruct) String() string // pointer methods

在官方effective go文档中,对两者区别描述如下:

  • 值方法(value methods)可以通过指针和值调用,但是指针方法(pointer methods)只能通过指针来调用。
  • 但有一个例外,如果某个值是可寻址的(addressable,或者说左值),那么编译器会在值调用指针方法时自动插入取地址符,使得在此情形下看起来像指针方法也可以通过值来调用。
type Foo struct {
    name string
}
func (f *Foo) PointerMethod() {
    fmt.Println("pointer method on", f.name)
}
func (f Foo) ValueMethod() {
    fmt.Println("value method on", f.name)
}
func NewFoo() Foo { // 返回一个右值,不可寻址
    return Foo{name: "right value struct"}
}
func main() {
    f1 := Foo{name: "value struct"}
    f1.PointerMethod() // 编译器会自动插入取地址符,变为 (&f1).PointerMethod()
    f1.ValueMethod()

    f2 := &Foo{name: "pointer struct"}
    f2.PointerMethod() 
    f2.ValueMethod() // 编译器会自动解引用,变为 (*f2).PointerMethod()

    NewFoo().ValueMethod()
    NewFoo().PointerMethod() // Error!!!
}

简而言之,就是不管是普通对象还是指针,都可以调用他们的值方法和指针方法,因为编译器会自行处理,但是对于右值(也就是通过函数返回的临时结构体变量等),只能调用值方法,不能调用指针方法。(备注:对于左值和右值的区别,最重要区别就是是否可以被寻址,可以被寻址的是左值,既可以出现在赋值号左边也可以出现在右边;不可以被寻址的即为右值,比如函数返回值、字面值、常量值等等,只能出现在赋值号右边。)

对于某个特定场景,两者如何取舍其实和另一个问题等价:就是你在定义函数时如何传参——是传值还是传指针。比如上述例子:

func (f *Foo) PointerMethod() {
    fmt.Println("pointer method on ", f.name)
}
func (f Foo) ValueMethod() {
    fmt.Println("value method on", f.name)
}
可以转换为下面两个函数进行考虑,用 Go 的术语来说,就是将函数的receiver看做是 argument:
func PointerMethod(f *Foo) {
    fmt.Println("pointer method on ", f.name)
}
func ValueMethod(f Foo)  {
    fmt.Println("value method on", f.name)
}

在定义receiver为值还是指针时,主要有以下几个考虑点:

  1. 方法是否需要修改receiver本身。如果需要,那receiver必然要是指针。
  2. 效率问题。如果receiver是值,那在方法调用时一定会产生 struct 拷贝,而大对象拷贝代价很大。
  3. 一致性。对于同一个struc 的方法,value method和pointer method混杂用肯定是优雅。

那啥时候用value method呢?很简单的不可变对象使用value method可以减轻gc负担,貌似也就这些好处了。因此请记住:遇事不决请用pointer method!!!

对于第一条,如果需要修改receiver本身,必须用指针,我再举个例子:

type N int
func (n N) value() {  // value method
    n++
    fmt.Printf("v:%p, %v\n", &n, n)
}
func (n *N) pointer() { // point method
    (*n)++
    fmt.Printf("p:%p, %v\n", n, *n)
}
func main() {
    var a N = 5
    a.value()
    a.pointer()
    fmt.Printf("a:%p,%v\n", &a, a)
}

输出:

v: 0x8200741c8, 26  // 虽然n被打印为26,但是在main()中,n的值还是25,未修改!!!
p: 0x8200741c0, 26 
a: 0x8200741c0, 26  // n的值被修改为26,是通过a.pointer()修改的!!!

方法集

所谓“方法集”,简单来说,就是对于普通类型和指针类型,所包含的方法集合,我们先看个例子:

type S struct{}
type T struct{
    S  // 匿名嵌入字段
}
func (S) sVal() {}
func (*S) sPtr() {}
func (T) sVal() {}
func (*T) sPtr() {}
func methodSet(a interface()) {
    t := reflect.TypeOf(a)
    for i, n := 0, t.NumMethod(); i < n; i++ {
        m := t.Method(i)
        fmt.Println(m.Name, m.Type)
    }
}
func main() {
    var t T
    methodSet(t)  // 显示T方法集
    println("---------------")
    methodSet(&t) // 显示*T方法集
}

输出:

sVal func(main.T)
tVal func(main.T)
----------------
sPtr func(*main.T)
sVal func(*main.T)
tPtr func(*main.T)
tVal func(*main.T)

可以看出,普通类型的方法集,是值方法;指针类型的方法集,是值方法 + 指针方法,更多情况可总结如下:

  • 类型T方法集包含所有的receive T方法;
  • 类型*T方法集包含所有receive T + *T方法;
  • 匿名嵌入S,T方法集包含所有receive T方法;
  • 匿名嵌入*S,T方法集包含所有receive S + *S方法;
  • 匿名嵌入S或*S,*T方法集包含所有receive S + *S方法。

总结

对于这一章内容,“匿名字段”用的非常多,它是其声明中只有类型而没有名称的字段,可以以一种很自然的方式为被嵌入的类型带来新的属性和能力。不过,我们需要小心可能产生“屏蔽”现象的地方,尤其是当存在多个嵌入字段或者多层嵌入的时候,“屏蔽”现象可能会让你的实际引用与你的预期不符。

另外,你一定要梳理清楚值方法和指针方法的不同之处,包括这两种方法各自能做什么、不能做什么以及会影响到其所属类型的哪些方面。这涉及值的修改、方法集合和接口实现。再次强调,嵌入字段是实现类型间组合的一种方式,这与继承没有半点儿关系。Go 语言虽然支持面向对象编程,但是根本就没有“继承”这个概念。

最后就是“方法集”,对于普通类型和指针类型,当存在匿名字段时,他们的值方法和指针方法的所属关系,这个是需要掌握的,这里我们没有讨论实际的应用场景,但是当涉及到接口实现和类型转换时,如果对这块知识掌握不够的话,转换会非常容易出现问题,后面在讲接口时,这块会再去讲解。对于方法表达式这块,这块知识不容易和其它知识混淆,也不难掌握,大家可以自行查阅相关资料即可。

楼仔

2021/05/04  阅读:20  主题:默认主题

作者介绍

楼仔