您好,登录后才能下订单哦!
写一个简单的方法:
type Point struct{X, Y float64}
// 普通的函数
func Distance(p, q Point) float64 {
return math.Hypot(q.X-p.X, q.Y-p.Y)
}
// 同样的作用,用方法实现
func (p Point) Distance(q Point) float64 {
return math.Hypot(q.X-p.X, q.Y-p.Y)
}
接收者:附加的参数 p 称为方法的接收者。
调用方法的时候,接收者在方法名的前面。这样就和声明保持一致:
p := Point{1, 2}
q := Point{4, 6}
fmt.Println(Distance(p, q)) // 函数调用
fmt.Println(p.Distance(q)) // 方法调用
选择子:表达是 p.Distance 称作选择子(selector),因为它为接收者 p 选择合适的 Distance 方法。
对于函数,它会复制每一只实参变量。如果函数需要更新一个变量,或者是因为实参太大而需要避免复制整个实参,就需要使用指针来传递变量的地址。
对于方法的接受者,也可以将方法绑定到指针类型。习惯上遵循如果一个类型的任何一个方法使用指针接收者,那么所有该类型的方法都应该使用指针接收者,即使有些方法不一定需要。
另外,为了防止混淆,不允许本身是指针的类型进行方法声明,会有编译错误:
type p *int
func (p) f() { /*...*/ } // 编译错误:非法的接收者类型
通常是在相同的表达式里使用和调用方法,但是把两个操作分开也是可以的。选择子 p.Distance 可以赋予一个方法变量,它是一个函数,把方法(Point.Distance)绑定到一个接收者 p 上。函数只需要提供实参而不需要提供接收者就能够调用:
p := Point{1, 2}
q := Point{4, 6}
distanceFromP := p.Distance // 方法变量
fmt.Println(distanceFromP(q))
这里 p.Distance 是选择子,把它赋值给变量 distanceFromP,这个变量就是方法变量,并且这个变量是一个函数。
如果包内的 API 调用一个函数值,并且使用者期望这个函数的行为是调用一个特定接收者的方法,方法变量就非常有用。使用方法变量还可以是代码更加简洁:
type Rocket struct { /* ... */ }
func (r *Rocket) Launch() { /* ... */ }
r := new(Rocket)
time.AfterFunc(10 * time.Second, func() { r.Launch() }) // 如果没有方法变量,那么要把执行一个方法包在一个函数里,等到函数被调用后执行
time.AfterFunc(10 * time.Second, r.Launch) // 使用方法变量,这里 r.Launch 就是一个函数,只是没有赋值给某个变量,没有函数名
函数 time.AfterFunc 的作用是在指定的延迟后调用一个函数。上面说了,方法变量也是函数。
调用方法的时候必须提供接收者,并且按照选择子的语法进行调用。
方法表达式,写成 T.f 或者 (*T.f)。
其中 T 是类型,是一种函数变量,把原来方法的接收者替换成函数的第一个形参,因此它可以像平常的函数一样调用:
p := Point{1, 2}
q := Point{4, 6}
distance := Point.Distance // 方法表达式
fmt.Println(distance(p, q))
fmt.Printf("%T\n", distance) // "func(Point, Point) float64"
如果需要一个值来代表多个方法中的一个,而方法都属于同一个类型,方法表达式可以实现让这个值所对应的方法来处理不同的接收者。就是可以把一个方法变成一个函数,函数的变量会增加一个,第一个变量就是原来方法中的接收者。其实各个参数的顺序还是一样的,原本第一个参数在 func 前,现在移动到了 func 后面。 p.Distance(q) 变成了 distance(p, q)。
io包定义了很多有用的接口:
io.Writer 是一个广泛使用的接口,它负责所有可以写入字节的抽象,包括但不限于下面列举的这些:
接口值,就是一个接口类型的值。分两个部分:
var w io.Writer // 声明接口,动态类型和动态值都是nil
w = os.Stdout // 有动态类型,也有动态值
w = io.Writer(os.Stdout) // 和上面这句等价,把一个具体类型显式转换为接口类型
w = new(bytes.Buffer) // 有动态类型,也有动态值
w = nil // 把动态类型和动态值都设置为nil,恢复到声明时的状态
接口值可以用 == 和 != 来比较。动态类型一致,然后动态值相等(使用动态类型的 == 来比较),那么接口值相等。接口值都是nil也是相等的。
可以作为map的key,也可以作为switch语句的操作数,因为可以比较。
动态值可能是不可比较的类型,比如切片。对这样的接口进行比较,就会Panic。把这样的接口用作map的key或者switch语句的操作数时也同样会Panic。所以,仅在能确认接口值包含的动态值可以比较时,才比较接口值。
fmt 包的 %T 打印出来的就是动态类型。在内部实现中,fmt 用反射来拿到接口动态类型的名字。
空的接口值(动态类型和动态值都为空)和仅仅动态值为nil的接口值是不一样的。
const debug = true
func main() {
var buf *bytes.Buffer
if debug {
buf = new(bytes.Buffer)
}
f(buf)
if debug {
// ...使用 buf...
}
}
// 如果 out 不是 nil,那么会向其写入输出的数据
func f(out io.Writer) {
// ...其他代码...
if out != nil {
out.Write([]byte("done\n"))
}
}
这里,把一个类型为 *bytes.Buffer 的空指针赋给了 out 参数,此时 out 的动态值为空。但它的动态类型是 *bytes.Buffer。就是说 out 是一个包含空指针的非空接口,所以这里的检查 out != nil
是 true,防御不了这种情况。
对于某些类型,比如 *os.File,空接收值是合法的。但是对于这里的 *buyes.Buffer,要求接收者不能为空,于是运行时会Panic。
这里的解决方案是,把 main 函数中的 buf 类型修改为 io.Writer,从而避免在最开始就把一个功能不完整的值赋给一个接口:
var buf io.Writer
if debug {
buf = new(bytes.Buffer)
}
f(buf)
类型断言是一个作用在接口值上的操作,代码类似于x(T)
,x是一个接口类型的表达式,而T是一个类型(称为断言类型)。类型断言会检查操作数的动态类型是否满足指定的断言类型。
这里有两种可能:
具体类型
如果断言类型T是一个具体类型,断言类型会检查x的动态类型是否就是T。如果检查成功,返回x的动态值,返回的类型就是T。如果检查失败,那么操作崩溃。
接口类型
如果断言类型T是一个接口类型,断言类型会检查x的动态类型是否满足T。如果检查成功,动态值并没有提取出来,仍然是一个接口值,接口值的类型和值部分也不会变,只是结果类型为接口类型T。就是说,这里类型断言就是一个接口值表达式,从一个接口类型变为拥有另外一套方法的接口类型,但保留了接口值中动态类型和动态值部分。如果检查失败还是会崩溃。
类型断言可以返回两个结果,此时操作不会因为检查失败而崩溃。多出来的返回值是一个布尔型,用来指示断言是否成功。按照惯例,一般变量名用ok。如果操作失败,ok为false,而第一个返回值会是断言类型的零值。
接口有两种不同的风格。
第一种风格下,典型的比如:io.Reader、io.Writer、fmt.Stringer、sort.Interface、http.Handler 和 error。接口上的各种方法突出了满足这个接口的具体类型之间的相似性,但隐藏了各个具体类型的布局和各自特有的功能。这种风格强调了方法,而不是具体类型。
第二种风格则充分利用了接口值能够容纳各种具体类型的能力,它把接口作为这些类型的联合(union)来使用。类型断言用来在运行时区分这些类型并分别处理。这这种风格中,强调的是满足这个接口的具体类型,而不是这个接口的方法(经常是没变方法的空接口),也不注重信息隐藏。这种风格的接口使用方式称为可识别联合(discriminated union)。
如果对面向对象熟悉,这两种风格分别对应:
不要一开始就定义接口,每个接口却只是一个单独的实现。这种接口是不必要的抽象,还会有运行时的成本。仅在有两个或多个具体类型需要按统一的方式处理时才需要接口。
上面的建议也有特例,如果接口和类型实现出于依赖的原因不能放在同一个包里边,那么一个接口只有一个具体类型实现也是可以的。在这种情况下,接口是一种解耦两个包的好方式。
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。