mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2024-11-28 09:09:07 +00:00
160 lines
8.2 KiB
Markdown
160 lines
8.2 KiB
Markdown
## 6.2. 基于指针对象的方法
|
||
|
||
当调用一个函数时，会对其每一个参数值进行拷贝，如果一个函数需要更新一个变量，或者函数的其中一个参数实在太大我们希望能够避免进行这种默认的拷贝，这种情况下我们就需要用到指针了。对应到我们这里用来更新接收器的对象的方法，当这个接受者变量本身比较大时，我们就可以用其指针而不是对象来声明方法，如下：
|
||
|
||
```go
|
||
func (p *Point) ScaleBy(factor float64) {
|
||
p.X *= factor
|
||
p.Y *= factor
|
||
}
|
||
```
|
||
|
||
这个方法的名字是`(*Point).ScaleBy`。这里的括号是必须的；没有括号的话这个表达式可能会被理解为`*(Point.ScaleBy)`。
|
||
|
||
在现实的程序里，一般会约定如果Point这个类有一个指针作为接收器的方法，那么所有Point的方法都必须有一个指针接收器，即使是那些并不需要这个指针接收器的函数。我们在这里打破了这个约定只是为了展示一下两种方法的异同而已。
|
||
|
||
只有类型（Point）和指向他们的指针`(*Point)`，才可能是出现在接收器声明里的两种接收器。此外，为了避免歧义，在声明方法时，如果一个类型名本身是一个指针的话，是不允许其出现在接收器中的，比如下面这个例子：
|
||
|
||
```go
|
||
type P *int
|
||
func (P) f() { /* ... */ } // compile error: invalid receiver type
|
||
```
|
||
|
||
想要调用指针类型方法`(*Point).ScaleBy`，只要提供一个Point类型的指针即可，像下面这样。
|
||
|
||
```go
|
||
r := &Point{1, 2}
|
||
r.ScaleBy(2)
|
||
fmt.Println(*r) // "{2, 4}"
|
||
```
|
||
|
||
或者这样：
|
||
|
||
```go
|
||
p := Point{1, 2}
|
||
pptr := &p
|
||
pptr.ScaleBy(2)
|
||
fmt.Println(p) // "{2, 4}"
|
||
```
|
||
或者这样:
|
||
|
||
```go
|
||
p := Point{1, 2}
|
||
(&p).ScaleBy(2)
|
||
fmt.Println(p) // "{2, 4}"
|
||
```
|
||
|
||
不过后面两种方法有些笨拙。幸运的是，go语言本身在这种地方会帮到我们。如果接收器p是一个Point类型的变量，并且其方法需要一个Point指针作为接收器，我们可以用下面这种简短的写法：
|
||
|
||
```go
|
||
p.ScaleBy(2)
|
||
```
|
||
|
||
编译器会隐式地帮我们用&p去调用ScaleBy这个方法。这种简写方法只适用于“变量”，包括struct里的字段比如p.X，以及array和slice内的元素比如perim[0]。我们不能通过一个无法取到地址的接收器来调用指针方法，比如临时变量的内存地址就无法获取得到：
|
||
|
||
```go
|
||
Point{1, 2}.ScaleBy(2) // compile error: can't take address of Point literal
|
||
```
|
||
|
||
但是我们可以用一个`*Point`这样的接收器来调用Point的方法，因为我们可以通过地址来找到这个变量，只要用解引用符号`*`来取到该变量即可。编译器在这里也会给我们隐式地插入`*`这个操作符，所以下面这两种写法等价的：
|
||
|
||
```Go
|
||
pptr.Distance(q)
|
||
(*pptr).Distance(q)
|
||
```
|
||
|
||
这里的几个例子可能让你有些困惑，所以我们总结一下：在每一个合法的方法调用表达式中，也就是下面三种情况里的任意一种情况都是可以的：
|
||
|
||
要么接收器的实际参数和其形式参数是相同的类型，比如两者都是类型T或者都是类型`*T`：
|
||
|
||
```go
|
||
Point{1, 2}.Distance(q) // Point
|
||
pptr.ScaleBy(2) // *Point
|
||
```
|
||
|
||
或者接收器实参是类型T，但接收器形参是类型`*T`，这种情况下编译器会隐式地为我们取变量的地址：
|
||
|
||
```go
|
||
p.ScaleBy(2) // implicit (&p)
|
||
```
|
||
|
||
或者接收器实参是类型`*T`，形参是类型T。编译器会隐式地为我们解引用，取到指针指向的实际变量：
|
||
|
||
```go
|
||
pptr.Distance(q) // implicit (*pptr)
|
||
```
|
||
|
||
如果命名类型T（译注：用type xxx定义的类型）的所有方法都是用T类型自己来做接收器（而不是`*T`），那么拷贝这种类型的实例就是安全的；调用他的任何一个方法也就会产生一个值的拷贝。比如time.Duration的这个类型，在调用其方法时就会被全部拷贝一份，包括在作为参数传入函数的时候。但是如果一个方法使用指针作为接收器，你需要避免对其进行拷贝，因为这样可能会破坏掉该类型内部的不变性。比如你对bytes.Buffer对象进行了拷贝，那么可能会引起原始对象和拷贝对象只是别名而已，实际上它们指向的对象是一样的。紧接着对拷贝后的变量进行修改可能会有让你有意外的结果。
|
||
|
||
**译注：** 作者这里说的比较绕，其实有两点：
|
||
|
||
1. 不管你的method的receiver是指针类型还是非指针类型，都是可以通过指针/非指针类型进行调用的，编译器会帮你做类型转换。
|
||
2. 在声明一个method的receiver该是指针还是非指针类型时，你需要考虑两方面的因素，第一方面是这个对象本身是不是特别大，如果声明为非指针变量时，调用会产生一次拷贝；第二方面是如果你用指针类型作为receiver，那么你一定要注意，这种指针类型指向的始终是一块内存地址，就算你对其进行了拷贝。熟悉C或者C++的人这里应该很快能明白。
|
||
|
||
### 6.2.1. Nil也是一个合法的接收器类型
|
||
|
||
就像一些函数允许nil指针作为参数一样，方法理论上也可以用nil指针作为其接收器，尤其当nil对于对象来说是合法的零值时，比如map或者slice。在下面的简单int链表的例子里，nil代表的是空链表：
|
||
|
||
```go
|
||
// An IntList is a linked list of integers.
|
||
// A nil *IntList represents the empty list.
|
||
type IntList struct {
|
||
Value int
|
||
Tail *IntList
|
||
}
|
||
// Sum returns the sum of the list elements.
|
||
func (list *IntList) Sum() int {
|
||
if list == nil {
|
||
return 0
|
||
}
|
||
return list.Value + list.Tail.Sum()
|
||
}
|
||
```
|
||
|
||
当你定义一个允许nil作为接收器值的方法的类型时，在类型前面的注释中指出nil变量代表的意义是很有必要的，就像我们上面例子里做的这样。
|
||
|
||
下面是net/url包里Values类型定义的一部分。
|
||
|
||
<u><i>net/url</i></u>
|
||
```go
|
||
package url
|
||
|
||
// Values maps a string key to a list of values.
|
||
type Values map[string][]string
|
||
// Get returns the first value associated with the given key,
|
||
// or "" if there are none.
|
||
func (v Values) Get(key string) string {
|
||
if vs := v[key]; len(vs) > 0 {
|
||
return vs[0]
|
||
}
|
||
return ""
|
||
}
|
||
// Add adds the value to key.
|
||
// It appends to any existing values associated with key.
|
||
func (v Values) Add(key, value string) {
|
||
v[key] = append(v[key], value)
|
||
}
|
||
```
|
||
|
||
这个定义向外部暴露了一个map的命名类型，并且提供了一些能够简单操作这个map的方法。这个map的value字段是一个string的slice，所以这个Values是一个多维map。客户端使用这个变量的时候可以使用map固有的一些操作（make，切片，m[key]等等），也可以使用这里提供的操作方法，或者两者并用，都是可以的：
|
||
|
||
<u><i>gopl.io/ch6/urlvalues</i></u>
|
||
```go
|
||
m := url.Values{"lang": {"en"}} // direct construction
|
||
m.Add("item", "1")
|
||
m.Add("item", "2")
|
||
|
||
fmt.Println(m.Get("lang")) // "en"
|
||
fmt.Println(m.Get("q")) // ""
|
||
fmt.Println(m.Get("item")) // "1" (first value)
|
||
fmt.Println(m["item"]) // "[1 2]" (direct map access)
|
||
|
||
m = nil
|
||
fmt.Println(m.Get("item")) // ""
|
||
m.Add("item", "3") // panic: assignment to entry in nil map
|
||
```
|
||
|
||
对Get的最后一次调用中，nil接收器的行为即是一个空map的行为。我们可以等价地将这个操作写成Value(nil).Get("item")，但是如果你直接写nil.Get("item")的话是无法通过编译的，因为nil的字面量编译器无法判断其准确类型。所以相比之下，最后的那行m.Add的调用就会产生一个panic，因为他尝试更新一个空map。
|
||
|
||
由于url.Values是一个map类型，并且间接引用了其key/value对，因此url.Values.Add对这个map里的元素做任何的更新、删除操作对调用方都是可见的。实际上，就像在普通函数中一样，虽然可以通过引用来操作内部值，但在方法想要修改引用本身时是不会影响原始值的，比如把他置换为nil，或者让这个引用指向了其它的对象，调用方都不会受影响。（译注：因为传入的是存储了内存地址的变量，你改变这个变量本身是影响不了原始的变量的，想想C语言，是差不多的）
|