Tuesday, December 22, 2020
A tour of Go (4) - 方法和接口
1. 方法
Go 没有类。不过你可以为结构体类型定义方法。
方法就是一类带特殊的 接收者 参数的函数。
方法接收者在它自己的参数列表内,位于 func
关键字和方法名之间。
在此例中,Abs
方法拥有一个名为 v
,类型为 Vertex
的接收者。
package main
import (
"fmt"
"math"
)
type Vertex struct { // 相当于“类的变量属性等”
X, Y float64
}
func (v Vertex) Abs() float64 { // 相当于为结构体定义函数,即“类的函数方法”
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func main() {
v := Vertex{3, 4}
fmt.Println(v.Abs())
// fmt.Println(v.Abs()) 这样会报错:undefined: Abs
}
指针接收者:你可以为指针接收者声明方法。
这意味着对于某类型 T
,接收者的类型可以用 *T
的文法。(此外,T
不能是像 *int
这样的指针。)
例如,这里为 *Vertex
定义了 Scale
方法。
指针接收者的方法可以修改接收者指向的值(就像 Scale
在这做的)。由于方法经常需要修改它的接收者,指针接收者比值接收者更常用。
type Vertex struct {
X, Y float64
}
func (v Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
//func (v Vertex) Scale(f float64) 值接收者,不会修改v Vertex的值,最终print=5
func (v *Vertex) Scale(f float64) { // 指针接收者,会修改v Vertex的值
v.X = v.X * f
v.Y = v.Y * f
}
func main() {
v := Vertex{3, 4}
v.Scale(10)
fmt.Println(v.Abs()) // result:50
}
若使用值接收者,那么 Scale
方法会对原始 Vertex
值的副本进行操作。(对于函数的其它参数也是如此。)Scale
方法必须用指针接受者来更改 main
函数中声明的 Vertex
的值。
指针与函数:现在我们要把 Abs
和 Scale
方法重写为函数。
func Abs(v Vertex) float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func Scale(v *Vertex, f float64) {
v.X = v.X * f
v.Y = v.Y * f
}
func main() {
v := Vertex{3, 4}
Scale(&v, 10)
fmt.Println(Abs(v)) // 50
}
注意:带指针参数的函数必须接受一个指针:
var v Vertex
ScaleFunc(v, 5) // 编译错误!
ScaleFunc(&v, 5) // OK
而以指针为接收者的方法被调用时,接收者既能为值又能为指针:
var v Vertex
v.Scale(5) // OK,为方便起见,Go 会将语句 v.Scale(5) 解释为 (&v).Scale(5)。
p := &v
p.Scale(10) // OK
方法与指针重定向:对于语句 v.Scale(5)
,即便 v
是个值而非指针,带指针接收者的方法也能被直接调用。也就是说,由于 Scale
方法有一个指针接收者,为方便起见,Go 会将语句 v.Scale(5)
解释为 (&v).Scale(5)
。
同样的事情也发生在相反的方向。
接受一个值作为参数的函数必须接受一个指定类型的值:
var v Vertex
fmt.Println(AbsFunc(v)) // OK
fmt.Println(AbsFunc(&v)) // 编译错误!
而以值为接收者的方法被调用时,接收者既能为值又能为指针:
var v Vertex
fmt.Println(v.Abs()) // OK
p := &v
fmt.Println(p.Abs()) // OK,p.Abs() 会被解释为 (*p).Abs()。
这种情况下,方法调用 p.Abs()
会被自动解释为 (*p).Abs()
。
选择值或指针作为接收者:
使用指针接收者的原因有二:
首先,方法能够修改其接收者指向的值。
其次,这样可以避免在每次调用方法时复制该值。若值的类型为大型结构体时,这样做会更加高效。
在本例中,Scale
和 Abs
接收者的类型为 *Vertex
,即便 Abs
并不需要修改其接收者。
func (v *Vertex) Scale(f float64) {
v.X = v.X * f
v.Y = v.Y * f
}
func (v *Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func main() {
v := &Vertex{3, 4}
fmt.Printf("Before scaling: %+v, Abs: %v\n", v, v.Abs())//&{X:3 Y:4}, Abs:5
v.Scale(5)
fmt.Printf("After scaling: %+v, Abs: %v\n", v, v.Abs())//&{X:15 Y:20},Abs:25
}
通常来说,所有给定类型的方法都应该有值或指针接收者,但并不应该二者混用。
2. 接口
接口类型 是由一组方法签名定义的集合。
接口类型的变量可以保存任何实现了这些方法的值。
type Abser interface {
Abs() float64
}
func main() {
var a Abser
f := MyFloat(-math.Sqrt2)
v := Vertex{3, 4}
a = f // a MyFloat 实现了 Abser
fmt.Println(a.Abs())
a = &v // a *Vertex 实现了 Abser
fmt.Println(a.Abs())
// 下面一行,v 是一个 Vertex(而不是 *Vertex)
// 所以没有实现 Abser。
a = v
fmt.Println(a.Abs()) // 所以,会报错
}
type MyFloat float64
func (f MyFloat) Abs() float64 { // 方法名为 Abs()
if f < 0 {
return float64(-f)
}
return float64(f)
}
type Vertex struct {
X, Y float64
}
func (v *Vertex) Abs() float64 { // 方法名为 Abs()
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
接口与隐式实现:类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明,也就没有“implements”关键字。
隐式接口从接口的实现中解耦了定义,这样接口的实现可以出现在任何包中,无需提前准备。
因此,也就无需在每一个实现上增加新的接口名称,这样同时也鼓励了明确的接口定义。(没看懂)
type I interface {
M()
}
type T struct {
S string
}
// 此方法表示类型 T 实现了接口 I,但我们无需显式声明此事。
// 因为方法名为M(),即接口 I 的方法
func (t T) M() {
fmt.Println(t.S)
}
func main() {
var i I = T{"hello"}
i.M() // result:hello
}
接口值:接口也是值。它们可以像其它值一样传递。
接口值可以用作函数的参数或返回值。
在内部,接口值可以看做包含值和具体类型的元组:
(value, type)
接口值保存了一个具体底层类型的具体值。
接口值调用方法时会执行其底层类型的同名方法。
package main
import (
"fmt"
"math"
)
type I interface {
M()
}
type T struct {
S string
}
func (t *T) M() { // 隐式实现
fmt.Println(t.S)
}
type F float64
func (f F) M() { // 隐式实现
fmt.Println(f)
}
func main() {
var i I
i = &T{"Hello"}
describe(i)
i.M()
i = F(math.Pi)
describe(i)
i.M()
}
func describe(i I) { // 接口值包括 v value 和 T type
fmt.Printf("(%v, %T)\n", i, i)
}
底层值为 nil 的接口值
即便接口内的具体值为 nil,方法仍然会被 nil 接收者调用。
在一些语言中,这会触发一个空指针异常,但在 Go 中通常会写一些方法来优雅地处理它(如本例中的 M
方法)。
注意: 保存了 nil 具体值的接口其自身并不为 nil。
package main
import "fmt"
type I interface {
M()
}
type T struct {
S string
}
func (t *T) M() {
if t == nil { // 处理空指针异常的 if 判断
fmt.Println("<nil>")
return
}
fmt.Println(t.S)
}
func main() {
var i I
var t *T // 空指针
fmt.Println(t) // <nil>
i = t
describe(i) // (<nil>, *main.T)
i.M() // <nil>
i = &T{"hello"}
describe(i) // (&{hello}, *main.T)
i.M()
}
func describe(i I) {
fmt.Printf("(%v, %T)\n", i, i)
}
nil 接口值
nil 接口值既不保存值也不保存具体类型。
为 nil 接口调用方法会产生运行时错误,因为接口的元组内并未包含能够指明该调用哪个 具体 方法的类型。
type I interface {
M()
}
func main() {
var i I
describe(i) // (<nil>, <nil>),不保存值和具体类型
i.M() // 运行时错误
}
func describe(i I) {
fmt.Printf("(%v, %T)\n", i, i)
}
空接口
指定了零个方法的接口值被称为 空接口:
interface{}
空接口可保存任何类型的值。(因为每个类型都至少实现了零个方法。)
空接口被用来处理未知类型的值。例如,fmt.Print
可接受类型为 interface{}
的任意数量的参数。
func main() {
var i interface{}
describe(i) // (<nil>, <nil>)
i = 42
describe(i) // (42, int)
i = "hello"
describe(i) // (hello, string)
}
func describe(i interface{}) {
fmt.Printf("(%v, %T)\n", i, i)
}
类型断言:提供了访问接口值底层具体值的方式。
t := i.(T)
该语句断言接口值 i
保存了具体类型 T
,并将其底层类型为 T
的值赋予变量 t
。
若 i
并未保存 T
类型的值,该语句就会触发一个恐慌(panic)。
为了 判断 一个接口值是否保存了一个特定的类型,类型断言可返回两个值:其底层值以及一个报告断言是否成功的布尔值。
t, ok := i.(T)
若 i
保存了一个 T
,那么 t
将会是其底层值,而 ok
为 true
。
否则,ok
将为 false
而 t
将为 T
类型的零值,程序并不会产生恐慌。
回顾:映射读取, elem, ok = m[key]
类型选择:是一种按顺序从几个类型断言中选择分支的结构。
类型选择与一般的 switch 语句相似,不过类型选择中的 case 为类型(而非值), 它们针对给定接口值所存储的值的类型进行比较。
switch v := i.(type) { // 关键字 type 替换了具体类型 T
case int:
fmt.Printf("Twice %v is %v\n", v, v*2)
case string:
fmt.Printf("%q is %v bytes long\n", v, len(v))
default:
fmt.Printf("I don't know about type %T!\n", v)
}
类型选择中的声明与类型断言 i.(T)
的语法相同,只是具体类型 T
被替换成了关键字 type
此选择语句判断接口值 i
保存的值类型是 T
还是 S
。在 T
或 S
的情况下,变量 v
会分别按 T
或 S
类型保存 i
拥有的值。在默认(即没有匹配)的情况下,变量 v
与 i
的接口类型和值相同。
Stringer:fmt
包中定义的 Stringer
是最普遍的接口之一。
type Stringer interface {
String() string
}
Stringer
是一个可以用字符串描述自己的类型。fmt
包(还有很多包)都通过此接口来打印值。
type Person struct {
Name string
Age int
}
func (p Person) String() string {
return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}
func main() {
a := Person{"Arthur Dent", 42}
fmt.Println(a) // Arthur Dent (42 years)
// 如果注释掉 String() 方法,Println 结果为:即打印 {Arthur Dent 42}
}
练习:Stringer:https://tour.go-zh.org/methods/18
题目描述:通过让 IPAddr
类型实现 fmt.Stringer
来打印点号分隔的地址。
例如,IPAddr{1, 2, 3, 4}
应当打印为 "1.2.3.4"
。
package main
import "fmt"
type IPAddr [4]byte
// TODO: 给 IPAddr 添加一个 "String() string" 方法
func (ip IPAddr) String() string { // 因为类型是 [4]byte,所以可以直接按照序号 0-3
return fmt.Sprintf("%v.%v.%v.%v", ip[0], ip[1], ip[2], ip[3])
}
func main() {
hosts := map[string]IPAddr{
"loopback": {127, 0, 0, 1},
"googleDNS": {8, 8, 8, 8},
}
for name, ip := range hosts {
fmt.Printf("%v: %v\n", name, ip)
}
}
错误:Go 程序使用 error
值来表示错误状态。
与 fmt.Stringer
类似,error
类型是一个内建接口:
type error interface {
Error() string
}
(与 fmt.Stringer
类似,fmt
包在打印值时也会满足 error
。)
通常函数会返回一个 error
值,调用的它的代码应当判断这个错误是否等于 nil
来进行错误处理。
i, err := strconv.Atoi("42")
if err != nil {
fmt.Printf("couldn't convert number: %v\n", err)
return
}
fmt.Println("Converted integer:", i)
error
为 nil 时表示成功;非 nil 的 error
表示失败。
练习:错误 https://tour.go-zh.org/methods/20
题目描述:从之前的练习中复制 Sqrt
函数,修改它使其返回 error
值。
Sqrt
接受到一个负数时,应当返回一个非 nil 的错误值。复数同样也不被支持。
创建一个新的类型
type ErrNegativeSqrt float64
并为其实现
func (e ErrNegativeSqrt) Error() string
方法使其拥有 error
值,通过 ErrNegativeSqrt(-2).Error()
调用该方法应返回 "cannot Sqrt negative number: -2"
。
注意: 在 Error
方法内调用 fmt.Sprint(e)
会让程序陷入死循环。可以通过先转换 e
来避免这个问题:fmt.Sprint(float64(e))
。这是为什么呢?
修改 Sqrt
函数,使其接受一个负数时,返回 ErrNegativeSqrt
值。
package main
import (
"fmt"
)
type ErrNegativeSqrt float64 // 创建一个新类型
func (e ErrNegativeSqrt) Error() string { // 为新类型实现方法,名Error(),返回string
return fmt.Sprintf("cannot Sqrt negative number: %v", float64(e))
}
func Sqrt(x float64) (float64, error) {
if x < 0 {
return 0, ErrNegativeSqrt(x)
}
z := 1.0
for i := 0; i < 10; i++{
z -= (z*z - x) / (2*x)
}
return z, nil
}
func main() {
fmt.Println(Sqrt(2)) // 1.4142103896495881 <nil>
fmt.Println(Sqrt(-2)) // 0 cannot Sqrt negative number: -2
}
将 fmt.Sprint(float64(e))
改为 fmt.Sprint(e)
, 将会栈溢出:runtime: goroutine stack exceeds 250000000-byte limit fatal error: stack overflow
理解1:第一次执行 ErrNegativeSqrt
的 Error()
函数,是由 main
函数中的 fmt.Println(Sqrt(-2))
触发的。Sqrt(-2)
返回 error 为 ErrNegativeSqrt
,在main
中打印这个 error,就会执行 ErrNegativeSqrt
的 Error()
函数。
然后在 Error()
函数内部,执行 fmt.Sprintf("cannot Sqrt negative number: %v", e)
,e
为ErrNegativeSqrt
,所以,再一次打印 ErrNegativeSqrt
,所以,还会调用 ErrNegativeSqrt
的 Error()
函数。这样就出现了死循环,直到调用栈溢出报错。
理解2:fmt.Sprint(e)
will call e.Error()
to convert the value e
to a string. If the Error()
method calls fmt.Sprint(e)
, then the program recurses until out of memory. You can break the recursion by converting the e
to a value without String
or Error
method.
Reader:io
包指定了 io.Reader
接口,它表示从数据流的末尾进行读取。
Go 标准库包含了该接口的许多实现,包括文件、网络连接、压缩和加密等等。
io.Reader
接口有一个 Read
方法:
func (T) Read(b []byte) (n int, err error) // 将数据填充到切片 b 中
Read
用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时,它会返回一个 io.EOF
错误。
示例代码创建了一个 strings.Reader
并以每次 8 字节的速度读取它的输出。
package main
import (
"fmt"
"io"
"strings"
)
func main() {
r := strings.NewReader("Hello, Reader!")
b := make([]byte, 8) // 保证以每次 8 字节的速度读取它的输出
for {
n, err := r.Read(b) // 返回填充的字节数 n 和错误值 err
fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
fmt.Printf("b[:n] = %q\n", b[:n]) // 循环赋值,每次把前 n 位覆盖了
if err == io.EOF { // 遇到数据流的结尾时,Read 会返回一个 io.EOF 错误赋值给 err。
break
}
}
}
/*
Results:
n = 8 err = <nil> b = [72 101 108 108 111 44 32 82]
b[:n] = "Hello, R"
n = 6 err = <nil> b = [101 97 100 101 114 33 32 82]
b[:n] = "eader!"
n = 0 err = EOF b = [101 97 100 101 114 33 32 82]
b[:n] = ""
*/
练习:Reader https://tour.go-zh.org/methods/22
题目描述:实现一个 Reader
类型,它产生一个 ASCII 字符 'A'
的无限流。
package main
import "golang.org/x/tour/reader"
type MyReader struct{}
// TODO: 给 MyReader 添加一个 Read([]byte) (int, error) 方法
func (r MyReader) Read(buf []byte) (int, error) {
for i := 0; i < len(buf); i++ {
buf[i] = 'A'
}
return len(buf), nil // 由上面例子可以看出,返回填充的字节数 n 和错误值 err = nil
}
func main() {
reader.Validate(MyReader{}) // Result: OK! 即完成了题目要求
}
练习:rot13Reader https://tour.go-zh.org/methods/23
题目描述:有种常见的模式是一个 io.Reader
包装另一个 io.Reader
,然后通过某种方式修改其数据流。
例如,gzip.NewReader
函数接受一个 io.Reader
(已压缩的数据流)并返回一个同样实现了 io.Reader
的 *gzip.Reader
(解压后的数据流)。
编写一个实现了 io.Reader
并从另一个 io.Reader
中读取数据的 rot13Reader
,通过应用 rot13 代换密码对数据流进行修改。
rot13Reader
类型已经提供。实现 Read
方法以满足 io.Reader
。
package main
import (
"io"
"os"
"strings"
)
type rot13Reader struct {
r io.Reader
}
// rot13代换代码:1. [a, n): A(a) +13 -> N(n); 2. [n, z]: N(n) - 13 -> A(a)
func (r13 rot13Reader) Read(buf []byte) (int, error) {
inbuf := make([]byte, 128) // 创建一个 inbuf 来接收 r13 中 io.Reader 的输入
n, err := r13.r.Read(inbuf)
if err != nil{ // 判断是否已经读完了 inbuf,读完了就返回这个非nil 的 err
return 0, err
}
for i:= 0; i < n; i++ { // 根据rot13代换密码,将变换后值的赋值给 buf
if (inbuf[i] >= 'A' && inbuf[i] < 'N') || (inbuf[i] >= 'a' && inbuf[i] < 'n') {
buf[i] = inbuf[i] + 13
}else if (inbuf[i] >= 'N' && inbuf[i] <= 'Z') || (inbuf[i] >= 'n' && inbuf[i] <= 'z') {
buf[i] = inbuf[i] - 13
}else { // Golang 里的"else if" 和 "else" 必须紧贴上一个语句末尾的 "}"
buf[i] = inbuf[i] // 不属于英文字母的,不做替换
}
}
return n, nil
}
func main() {
s := strings.NewReader("Lbh penpxrq gur pbqr!")
r := rot13Reader{s}
io.Copy(os.Stdout, &r) // Result: You cracked the code!
}
图像:image
包定义了 Image
接口:
package image
type Image interface {
ColorModel() color.Model
Bounds() Rectangle
At(x, y int) color.Color
}
注意: Bounds
方法的返回值 Rectangle
实际上是一个 image.Rectangle
,它在 image
包中声明。
(请参阅文档了解全部信息。)
color.Color
和 color.Model
类型也是接口,但是通常因为直接使用预定义的实现 image.RGBA
和 image.RGBAModel
而被忽视了。这些接口和类型由 image/color
包定义。
m := image.NewRGBA(image.Rect(0, 0, 100, 100))
fmt.Println(m.Bounds()) // (0,0)-(100,100)
fmt.Println(m.At(0, 0).RGBA()) // 0 0 0 0
练习:图像 https://tour.go-zh.org/methods/25
题目描述:还记得之前编写的图片生成器 吗?我们再来编写另外一个,不过这次它将会返回一个 image.Image
的实现而非一个数据切片。
定义你自己的 Image
类型,实现必要的方法并调用 pic.ShowImage
。
Bounds
应当返回一个 image.Rectangle
,例如 image.Rect(0, 0, w, h)
。
ColorModel
应当返回 color.RGBAModel
。
At
应当返回一个颜色。上一个图片生成器的值 v
对应于此次的 color.RGBA{v, v, 255, 255}
。
package main
import (
"golang.org/x/tour/pic"
"image"
"image/color"
)
type Image struct{
w int
h int
}
/* 参考
type Image interface {
ColorModel() color.Model
Bounds() Rectangle
At(x, y int) color.Color
}*/
func (self Image) ColorModel() color.Model {
return color.RGBAModel
}
func (self Image) Bounds() image.Rectangle {
return image.Rect(0, 0, self.w, self.h)
}
func (self Image) At(x int, y int) color.Color {
r := (uint8)((float64)(x) / (float64)(self.w) * 255.0)
g := (uint8)((float64)(y) / (float64)(self.h) * 255.0)
b := (uint8)((float64)(x * y) / (float64)(self.w * self.h) * 255.0)
return color.RGBA{r, g, b, 255}
}
func main() {
m := Image{255, 255}
pic.ShowImage(m)
}
结果: