gopl-zh.github.com/ch6/ch6-02.md

160 lines
8.2 KiB
Markdown
Raw Normal View History

2016-02-15 03:06:34 +00:00
## 6.2. 基于指针对象的方法
2015-12-09 07:45:11 +00:00
2016-02-15 03:06:34 +00:00
当调用一个函数时,会对其每一个参数值进行拷贝,如果一个函数需要更新一个变量,或者函数的其中一个参数实在太大我们希望能够避免进行这种默认的拷贝,这种情况下我们就需要用到指针了。对应到我们这里用来更新接收器的对象的方法,当这个接受者变量本身比较大时,我们就可以用其指针而不是对象来声明方法,如下:
2015-12-09 07:45:11 +00:00
```go
func (p *Point) ScaleBy(factor float64) {
2016-01-21 02:08:07 +00:00
p.X *= factor
p.Y *= factor
2015-12-09 07:45:11 +00:00
}
```
2016-02-15 03:06:34 +00:00
这个方法的名字是`(*Point).ScaleBy`。这里的括号是必须的;没有括号的话这个表达式可能会被理解为`*(Point.ScaleBy)`。
2015-12-09 07:45:11 +00:00
2016-02-15 03:06:34 +00:00
在现实的程序里一般会约定如果Point这个类有一个指针作为接收器的方法那么所有Point的方法都必须有一个指针接收器即使是那些并不需要这个指针接收器的函数。我们在这里打破了这个约定只是为了展示一下两种方法的异同而已。
2015-12-09 07:45:11 +00:00
2018-06-09 16:27:25 +00:00
只有类型Point和指向他们的指针`(*Point)`,才可能是出现在接收器声明里的两种接收器。此外,为了避免歧义,在声明方法时,如果一个类型名本身是一个指针的话,是不允许其出现在接收器中的,比如下面这个例子:
2015-12-09 07:45:11 +00:00
```go
type P *int
func (P) f() { /* ... */ } // compile error: invalid receiver type
```
2016-02-15 03:06:34 +00:00
想要调用指针类型方法`(*Point).ScaleBy`只要提供一个Point类型的指针即可像下面这样。
2015-12-09 07:45:11 +00:00
```go
r := &Point{1, 2}
r.ScaleBy(2)
fmt.Println(*r) // "{2, 4}"
```
2016-01-21 02:08:07 +00:00
2016-02-15 03:06:34 +00:00
或者这样:
2015-12-09 07:45:11 +00:00
```go
p := Point{1, 2}
pptr := &p
pptr.ScaleBy(2)
fmt.Println(p) // "{2, 4}"
```
2016-02-15 03:06:34 +00:00
或者这样:
2015-12-09 07:45:11 +00:00
```go
p := Point{1, 2}
(&p).ScaleBy(2)
fmt.Println(p) // "{2, 4}"
```
2016-02-15 03:06:34 +00:00
不过后面两种方法有些笨拙。幸运的是go语言本身在这种地方会帮到我们。如果接收器p是一个Point类型的变量并且其方法需要一个Point指针作为接收器我们可以用下面这种简短的写法
2016-01-02 13:17:21 +00:00
2015-12-09 07:45:11 +00:00
```go
p.ScaleBy(2)
```
2016-02-15 03:06:34 +00:00
编译器会隐式地帮我们用&p去调用ScaleBy这个方法。这种简写方法只适用于“变量”包括struct里的字段比如p.X以及array和slice内的元素比如perim[0]。我们不能通过一个无法取到地址的接收器来调用指针方法,比如临时变量的内存地址就无法获取得到:
2015-12-09 07:45:11 +00:00
```go
Point{1, 2}.ScaleBy(2) // compile error: can't take address of Point literal
```
2016-02-15 03:06:34 +00:00
但是我们可以用一个`*Point`这样的接收器来调用Point的方法因为我们可以通过地址来找到这个变量只要用解引用符号`*`来取到该变量即可。编译器在这里也会给我们隐式地插入`*`这个操作符,所以下面这两种写法等价的:
2015-12-09 07:45:11 +00:00
```Go
pptr.Distance(q)
(*pptr).Distance(q)
```
2016-02-15 03:06:34 +00:00
这里的几个例子可能让你有些困惑,所以我们总结一下:在每一个合法的方法调用表达式中,也就是下面三种情况里的任意一种情况都是可以的:
2015-12-09 07:45:11 +00:00
要么接收器的实际参数和其形式参数是相同的类型比如两者都是类型T或者都是类型`*T`
2016-01-02 13:17:21 +00:00
2015-12-09 07:45:11 +00:00
```go
Point{1, 2}.Distance(q) // Point
pptr.ScaleBy(2) // *Point
```
2017-04-03 17:08:24 +00:00
或者接收器实参是类型T但接收器形参是类型`*T`,这种情况下编译器会隐式地为我们取变量的地址:
2016-01-02 13:17:21 +00:00
2015-12-09 07:45:11 +00:00
```go
p.ScaleBy(2) // implicit (&p)
```
2017-04-03 17:08:24 +00:00
或者接收器实参是类型`*T`形参是类型T。编译器会隐式地为我们解引用取到指针指向的实际变量
2016-01-02 13:17:21 +00:00
2015-12-09 07:45:11 +00:00
```go
pptr.Distance(q) // implicit (*pptr)
```
2017-08-24 14:28:33 +00:00
如果命名类型T译注用type xxx定义的类型的所有方法都是用T类型自己来做接收器而不是`*T`那么拷贝这种类型的实例就是安全的调用他的任何一个方法也就会产生一个值的拷贝。比如time.Duration的这个类型在调用其方法时就会被全部拷贝一份包括在作为参数传入函数的时候。但是如果一个方法使用指针作为接收器你需要避免对其进行拷贝因为这样可能会破坏掉该类型内部的不变性。比如你对bytes.Buffer对象进行了拷贝那么可能会引起原始对象和拷贝对象只是别名而已实际上它们指向的对象是一样的。紧接着对拷贝后的变量进行修改可能会有让你有意外的结果。
2015-12-09 07:45:11 +00:00
2016-02-15 03:06:34 +00:00
**译注:** 作者这里说的比较绕,其实有两点:
2016-01-02 13:17:21 +00:00
2016-02-15 03:06:34 +00:00
1. 不管你的method的receiver是指针类型还是非指针类型都是可以通过指针/非指针类型进行调用的,编译器会帮你做类型转换。
2017-08-24 14:28:33 +00:00
2. 在声明一个method的receiver该是指针还是非指针类型时你需要考虑两方面的因素第一方面是这个对象本身是不是特别大如果声明为非指针变量时调用会产生一次拷贝第二方面是如果你用指针类型作为receiver那么你一定要注意这种指针类型指向的始终是一块内存地址就算你对其进行了拷贝。熟悉C或者C++的人这里应该很快能明白。
2015-12-09 07:45:11 +00:00
2022-08-04 06:58:52 +00:00
### 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语言是差不多的