Go语言核心手册-4.结构体&方法

4.1 匿名字段

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

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

4.2 方法覆盖

方法存在同名遮蔽问题，通过匿名字段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
}

4.3 值方法和指针方法

当你给某个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()修改的！！！

4.4 方法集

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

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方法。

4.5 总结

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

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

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