Go 萌新的初学之路 III

方法

在 Go 语言中，方法是一种特殊的函数，它与特定类型相关联。与其他面向对象语言不同，Go 没有类的概念，但允许你在任何自定义类型上定义方法。方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。在此例中，Abs 方法拥有一个名字为 v，类型为 Vertex 的接收者。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v Vertex) Abs() float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func main() {
17    v := Vertex{3, 4}
18    fmt.Println(v.Abs())
19}

输出

什么是方法？

在 Go 语言中，方法其实就是一种特殊的函数，只不过这个函数和某个特定的数据类型关联在一起了，可以把它想象成是"某种类型专属的函数"。
接收者就是那个拥有这个方法的具体对象。你可以把它理解为：

普通函数是独立的，任何人都可以调用
方法是"专属"的，只有特定类型的对象才能调用

实际例子

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Circle struct {
 9    radius float64
10}
11
12// 这是一个方法，属于Circle类型
13func (c Circle) Area() float64 {
14    return math.Pi * c.radius * c.radius
15}
16
17func main() {
18    myCircle := Circle{radius: 5}
19    
20    // 调用方法
21    circleArea := myCircle.Area()
22    fmt.Println("圆的面积是:", circleArea)
23}

输出

圆的面积是: 78.53981633974483

在这个例子中：

我们创建了一个 Circle 类型
给这个类型定义了一个计算面积的方法 Area
(c Circle) 是接收者，表示这个方法只属于 Circle 类型
当我们创建一个圆 myCircle 后，可以用点号调用它的方法：myCircle.Area()

值接收者与指针接收者的区别

Go 语言中方法的接收者可以是值也可以是指针，这有点类似于：

值接收者：你给朋友看照片，他只能看不能改指针接收者：你把实物给朋友，他可以修改它

1// 值接收者 - 不会修改原始数据
2func (c Circle) Double() {
3    c.radius = c.radius * 2  // 这个修改不会影响到原始的Circle
4}
5
6// 指针接收者 - 会修改原始数据
7func (c *Circle) RealDouble() {
8    c.radius = c.radius * 2  // 这个修改会真正改变Circle的radius
9}

方法即函数

如上所说，方法只是个带接收者参数的函数。现在这个 Abs 的写法就是个正常的函数，功能并没有什么变化。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func Abs(v Vertex) float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func main() {
17    v := Vertex{3, 4}
18    fmt.Println(Abs(v))
19}

输出

你也可以为非结构体类型声明方法。在下面的例子里，我们看到了一个带 Abs 方法的数值类型 MyFloat。
你只能为在同一个包中定义的接收者类型声明方法，而不能为其它别的包中定义的类型（包括 int 之类的内置类型）声明方法。
就是说接收者的类型定义和方法声明必须在同一包内。因此下面的例子是创建了 MyFloat 类型，而不是直接为 float64 添加方法。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type MyFloat float64
 9
10func (f MyFloat) Abs() float64 {
11    if f < 0 {
12        return float64(-f)
13    }
14    return float64(f)
15}
16
17func main() {
18    f := MyFloat(-math.Sqrt2)
19    fmt.Println(f.Abs())
20}

输出

1.4142135623730951

指针类型的接收者

你可以为指针类型的接收者声明方法。

这意味着对于某类型 T，接收者的类型可以用 *T 的文法。（此外，T 本身不能是指针，比如不能是 *int。）
指针接收者的方法可以修改接收者指向的值。由于方法经常需要修改它的接收者，指针接收者比值接收者更常用。
例如，下面为 *Vertex 定义了 Scale 方法。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v Vertex) Abs() float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func (v *Vertex) Scale(f float64) {
17    v.X = v.X * f
18    v.Y = v.Y * f
19}
20
21func main() {
22    v := Vertex{3, 4}
23    v.Scale(10)
24    fmt.Println(v.Abs())
25}

输出

试着移除第 16 行 Scale 函数声明中的 *，观察此程序的行为如何变化。

若使用值接收者，那么 Scale 方法会对原始 Vertex 值的副本进行操作。（对于函数的其它参数也是如此。）Scale 方法必须用指针接收者来更改 main 函数中声明的 Vertex 的值。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v Vertex) Abs() float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func (v Vertex) Scale(f float64) {
17    v.X = v.X * f
18    v.Y = v.Y * f
19}
20
21func main() {
22    v := Vertex{3, 4}
23    v.Scale(10)
24    fmt.Println(v.Abs()) // output: 5
25}

输出

指针与函数

现在我们要把 Abs 和 Scale 方法重写为函数。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func Abs(v Vertex) float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func Scale(v *Vertex, f float64) {
17    v.X = v.X * f
18    v.Y = v.Y * f
19}
20
21func main() {
22    v := Vertex{3, 4}
23    Scale(&v, 10)
24    fmt.Println(Abs(v))
25}

输出

方法与指针重定向

 1package main
 2
 3import "fmt"
 4
 5type Vertex struct {
 6    X, Y float64
 7}
 8
 9func (v *Vertex) Scale(f float64) {
10    v.X = v.X * f
11    v.Y = v.Y * f
12}
13
14func ScaleFunc(v *Vertex, f float64) {
15    v.X = v.X * f
16    v.Y = v.Y * f
17}
18
19func main() {
20    v := Vertex{3, 4}
21    v.Scale(2)
22    ScaleFunc(&v, 10)
23
24    p := &Vertex{4, 3}
25    p.Scale(3)
26    ScaleFunc(p, 8)
27
28    fmt.Println(v, p)
29}

输出

{60 80} &{96 72}

比较前两个程序，你大概会注意到带指针参数的函数必须接受一个指针：

1var v Vertex
2ScaleFunc(v, 5) // 编译错误！
3ScaleFunc(&v, 5) // OK

而接收者为指针的的方法被调用时，接收者既能是值又能是指针：

1var v Vertex
2v.Scale(5) // OK
3p := &v
4p.Scale(10) // OK

对于语句 v.Scale(5) 来说，即便 v 是一个值而非指针，带指针接收者的方法也能被直接调用。也就是说，由于 Scale 方法有一个指针接收者，为方便起见，Go 会将语句 v.Scale(5) 解释为 (&v).Scale(5)。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v Vertex) Abs() float64 {
13    return math.Sqrt(v.X*v.X + v.Y*v.Y)
14}
15
16func AbsFunc(v Vertex) float64 {
17    return math.Sqrt(v.X*v.X + v.Y*v.Y)
18}
19
20func main() {
21    v := Vertex{3, 4}
22    fmt.Println(v.Abs())
23    fmt.Println(AbsFunc(v))
24
25    p := &Vertex{4, 3}
26    fmt.Println(p.Abs())
27    fmt.Println(AbsFunc(*p))
28}

输出

5
5
5
5

这种情况下，方法调用 p.Abs() 会被解释为 (*p).Abs()。

1var v Vertex
2fmt.Println(AbsFunc(v)) // OK
3fmt.Println(AbsFunc(&v)) // 编译错误！

而以值为接收者的方法被调用时，接收者既能为值又能为指针：

1var v Vertex
2fmt.Println(v.Abs()) // OK
3p := &v
4fmt.Println(p.Abs()) // OK

选择值或指针作为接收者

使用指针接收者的原因有二：方法能够修改其接收者指向的值，还可以避免在每次调用方法时复制该值。若值的类型为大型结构体时，这样会更加高效。

在本例中，Scale 和 Abs 接收者的类型为 *Vertex，即便 Abs 并不需要修改其接收者。

通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用。（我们会在接下来几页中明白为什么。）

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Vertex struct {
 9    X, Y float64
10}
11
12func (v *Vertex) Scale(f float64) {
13    v.X = v.X * f
14    v.Y = v.Y * f
15}
16
17func (v *Vertex) Abs() float64 {
18    return math.Sqrt(v.X*v.X + v.Y*v.Y)
19}
20
21func main() {
22    v := &Vertex{3, 4}
23    fmt.Printf("缩放前：%+v，绝对值：%v\n", v, v.Abs())
24    v.Scale(5)
25    fmt.Printf("缩放后：%+v，绝对值：%v\n", v, v.Abs())
26}

输出

缩放前：&{X:3 Y:4}，绝对值：5
缩放后：&{X:15 Y:20}，绝对值：25

接口

接口类型是由一组方法签名定义的集合。简单来说，接口就像是一份"合同"，它只规定了"要做什么"，但不关心"怎么做"。
任何类型只要实现了接口中定义的所有方法，就被认为满足了这个接口。在 Go 中，不需要显式声明某个类型实现了某个接口，只要一个类型实现了接口要求的所有方法，它就自动满足了这个接口。这与其他语言如 Java 不同，Java 需要明确声明实现关系。

警告

示例代码的第 22 行存在一个错误。由于 Abs 方法只为 *Vertex （指针类型）定义，因此 Vertex（值类型）并未实现 Abser。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type Abser interface {
 9    Abs() float64
10}
11
12func main() {
13    var a Abser
14    f := MyFloat(-math.Sqrt2)
15    v := Vertex{3, 4}
16
17    a = f  // a MyFloat 实现了 Abser
18    a = &v // a *Vertex 实现了 Abser
19
20    // 下面一行，v 是一个 Vertex（而不是 *Vertex）
21    // 所以没有实现 Abser。
22    // a = v
23
24    fmt.Println(a.Abs())
25}
26
27type MyFloat float64
28
29func (f MyFloat) Abs() float64 {
30    if f < 0 {
31        return float64(-f)
32    }
33    return float64(f)
34}
35
36type Vertex struct {
37    X, Y float64
38}
39
40func (v *Vertex) Abs() float64 {
41    return math.Sqrt(v.X*v.X + v.Y*v.Y)
42}

输出

Abser接口只定义了一个方法：Abs() float64，意思是任何想要实现这个接口的类型都必须有一个名为Abs的方法，该方法不接受参数且返回一个float64值.

在代码中，有两个类型与这个接口相关：

MyFloat类型 - 直接实现了Abs()方法

1func (f MyFloat) Abs() float64 {
2     // 方法实现... 
3}

Vertex结构体 - 但这里有个关键点：Abs()方法是为*Vertex(指针类型)定义的，而不是Vertex(值类型)

1func (v *Vertex) Abs() float64 {
2    return math.Sqrt(v.X*v.X + v.Y*v.Y)
3}

那为什么 Vertex 值类型没有实现 Abser 接口，而 *Vertex 指针类型实现了呢？因为 Abs() 方法的接收者是 *Vertex（指针类型），而不是 Vertex（值类型）。这意味着：

指针接收者：当 Abs() 方法定义在 *Vertex 上时，只有 *Vertex 类型实现了 Abser 接口。
值不能自动转为指针：Go 语言不会自动将 Vertex 值转换为 *Vertex 指针来调用方法。

在示例代码中：

a = f 有效，因为 MyFloat 类型实现了 Abs() 方法；
a = &v 有效，因为 *Vertex 类型实现了 Abs() 方法；
a = v 无效，因为 Vertex 类型没有实现 Abs() 方法 - 这行被注释掉了，因为它会导致编译错误。

可以这样理解：

假设接口 Abser 是一个"会计算绝对值的东西"的规范
MyFloat 类型本身就知道如何计算自己的绝对值
但对于 Vertex 结构体，只有拿到它的地址(*Vertex)才能计算绝对值，而值本身(Vertex)不具备这个能力

这就是为什么 Go 的接口被称为"隐式接口"，它通过实现方法而不是声明来满足接口要求。

运行逻辑

首先，8~10 行定义了一个接口 Abser：

type Abser interface { Abs() float64 }

还有两个实现该接口的类型：MyFloat 和 *Vertex：

1. MyFloat 类型及其方法

1type MyFloat float64
2
3func (f MyFloat) Abs() float64 {
4    if f < 0 {
5        return float64(-f)
6    }
7    return float64(f)
8}

这里 MyFloat 是一个基于 float64 的自定义类型，它实现了 Abs() 方法，返回该浮点数的绝对值。在 Go 中，这被称为值接收者的方法。

2. Vertex 类型及其方法

1type Vertex struct {
2    X, Y float64
3}
4
5func (v *Vertex) Abs() float64 {
6    return math.Sqrt(v.X*v.X + v.Y*v.Y)
7}

Vertex 是一个包含 X 和 Y 坐标的结构体，它的 Abs() 方法使用指针接收者，计算从原点到该点的欧几里得距离。

 1func main() {
 2    var a Abser
 3    f := MyFloat(-math.Sqrt2)
 4    v := Vertex{3, 4}
 5
 6    a = f  // a MyFloat 实现了 Abser
 7    a = &v // a *Vertex 实现了 Abser
 8
 9    fmt.Println(a.Abs())
10}

执行过程：

变量声明：

var a Abser 声明一个 Abser 接口类型的变量 a
f := MyFloat(-math.Sqrt2) 创建一个值为 -√2 的 MyFloat 变量
v := Vertex{3, 4} 创建一个坐标为 (3,4) 的 Vertex 结构体

接口赋值：

a = f -> 将 MyFloat 类型的变量赋值给接口变量 a。这是合法的，因为 MyFloat 类型实现了 Abs() 方法，满足了 Abser 接口的要求。
a = &v -> 将 Vertex 的指针赋值给接口变量 a。注意这里必须是指针，因为 Abs() 方法是定义在 *Vertex 上的，而不是 Vertex 上。换句话说，*Vertex 类型实现了 Abser 接口，但 Vertex 类型没有。

方法调用：

fmt.Println(a.Abs()) -> 通过接口调用 Abs() 方法。虽然 a 是接口类型，但实际上它指向的是一个 *Vertex 类型的值（因为最后一次赋值是 a = &v），所以调用的是 *Vertex 的 Abs() 方法。
这将输出 5（即 √(3² + 4²)），这是点 (3,4) 到原点的距离。

这个简短的程序展示了 Go 语言面向接口编程的核心概念。

接口的隐式实现

类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明，也就没有 implements 关键字。隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。

 1package main
 2
 3import "fmt"
 4
 5type I interface {
 6    M()
 7}
 8
 9type T struct {
10    S string
11}
12
13// 此方法表示类型 T 实现了接口 I，不过我们并不需要显式声明这一点。
14func (t T) M() {
15    fmt.Println(t.S)
16}
17
18func main() {
19    var i I = T{"hello"}
20    i.M()
21}

答案

hello

接口是一种特殊的类型，它定义了一组方法的集合，但不提供具体实现。与其他编程语言不同的是，Go 采用了隐式接口实现的方式。这意味着类型通过实现一个接口的所有方法来自动实现该接口，而无需显式声明。你的代码示例中:

 1type I interface {
 2    M()
 3}
 4
 5type T struct {
 6    S string
 7}
 8
 9func (t T) M() {
10    fmt.Println(t.S)
11}

这里，结构体 T 实现了方法 M()，因此它自动实现了接口 I，尽管代码中没有明确声明这一点。

“implements” 关键字是什么？

在 Java 等其他面向对象语言中，当一个类实现一个接口时需要使用 implements 关键字来显式声明。例如在 Java 中:

1interface I {
2    void M();
3}
4
5class T implements I {
6    public void M() {
7        // 实现
8    }
9}

但 Go 没有 “implements” 关键字，只要一个类型实现了接口中定义的所有方法，它就自动实现了该接口，无需显式声明。

通俗理解：可以把 Go 的接口理解为一份"能力清单"。只要一个类型具备了这份清单上所列的所有"能力"(方法)，它就自动获得了这个接口的"资格证"，而不需要特意去申请或声明。

在上面的例子中，接口 I 要求有一个 M() 方法，结构体 T 正好有这个方法，所以 T 自动满足了接口 I 的要求，可以被当作接口 I 类型来使用，如 var i I = T{"hello"} 所示。

这种设计使得代码更加简洁灵活，并且允许开发者为现有类型"追加"接口实现，即使是对标准库或第三方库中的类型。

接口值

接口也是值，它们可以像其它值一样传递；接口值可以用作函数的参数或返回值。
在内部，接口值可以看做包含值和具体类型的元组：(value, type)。
接口值保存了一个具体底层类型的具体值，接口值调用方法时会执行其底层类型的同名方法。

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8type I interface {
 9    M()
10}
11
12type T struct {
13    S string
14}
15
16func (t *T) M() {
17    fmt.Println(t.S)
18}
19
20type F float64
21
22func (f F) M() {
23    fmt.Println(f)
24}
25
26func main() {
27    var i I
28
29    i = &T{"Hello"}
30    describe(i)
31    i.M()
32
33    i = F(math.Pi)
34    describe(i)
35    i.M()
36}
37
38func describe(i I) {
39    fmt.Printf("(%v, %T)\n", i, i)
40}

输出

(&{Hello}, *main.T)
Hello
(3.141592653589793, main.F)
3.141592653589793

底层值为 nil 的接口值

即便接口内的具体值为 nil，方法仍然会被 nil 接收者调用。

在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅地处理它（如本例中的 M 方法）。

注意: 保存了 nil 具体值的接口其自身并不为 nil。

 1package main
 2
 3import "fmt"
 4
 5type I interface {
 6    M()
 7}
 8
 9type T struct {
10    S string
11}
12
13func (t *T) M() {
14    if t == nil {
15        fmt.Println("<nil>")
16        return
17    }
18    fmt.Println(t.S)
19}
20
21func main() {
22    var i I
23
24    var t *T
25    i = t
26    describe(i)
27    i.M()
28
29    i = &T{"hello"}
30    describe(i)
31    i.M()
32}
33
34func describe(i I) {
35    fmt.Printf("(%v, %T)\n", i, i)
36}

输出

(<nil>, *main.T)
<nil>
(&{hello}, *main.T)
hello

nil 接口值

nil 接口值既不保存值也不保存具体类型。但为 nil 接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个具体方法的类型。

 1package main
 2
 3import "fmt"
 4
 5type I interface {
 6    M()
 7}
 8
 9func main() {
10    var i I
11    describe(i)
12    i.M()
13}
14
15func describe(i I) {
16    fmt.Printf("(%v, %T)\n", i, i)
17}

输出

(<nil>, <nil>)
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x492b99]

goroutine 1 [running]:
main.main()
/tmp/sandbox1833746970/prog.go:12 +0x19

空接口

指定了零个方法的接口值被称为空接口：interface{}。
空接口可保存任何类型的值。（因为每个类型都至少实现了零个方法。）
空接口被用来处理未知类型的值。例如，fmt.Print 可接受类型为 interface{} 的任意数量的参数。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    var i interface{}
 7    describe(i)
 8
 9    i = 42
10    describe(i)
11
12    i = "hello"
13    describe(i)
14}
15
16func describe(i interface{}) {
17    fmt.Printf("(%v, %T)\n", i, i)
18}

输出

(<nil>, <nil>)
(42, int)
(hello, string)

类型断言

总结

类型断言提供了访问接口值底层具体值的方式：t := i.(T)

该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。若 i 并未保存 T 类型的值，该语句就会触发一个 panic。

为了判断一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值：

t, ok := i.(T)

若 i 保存了一个 T，那么 t 将会是其底层值，而 ok 为 true。否则，ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生 panic。

请注意这种语法和读取一个映射时的相同之处。

这说的什么玩意。。
通俗点说，类型断言是 Go 语言中的一种机制，它允许我们检查并访问接口值中存储的具体类型值。

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6    var i interface{} = "hello"
 7
 8    s := i.(string)
 9    fmt.Println(s)
10
11    s, ok := i.(string)
12    fmt.Println(s, ok)
13
14    f, ok := i.(float64)
15    fmt.Println(f, ok)
16
17    f = i.(float64) // panic
18    fmt.Println(f)
19}

输出

hello
hello true
0 false
panic: interface conversion: interface {} is string, not float64

goroutine 1 [running]:
main.main()
/tmp/sandbox2560958058/prog.go:17 +0x13f

类型断言有两种主要形式：

简单形式：t := i.(T)

这种形式直接断言接口值i中保存的是T类型的值。
如果断言正确，t将获得i中存储的值。
如果断言错误（即i中不是T类型的值），程序会触发panic。

安全形式：t, ok := i.(T)

这种形式返回两个值：可能的转换结果和一个布尔值。
如果i中确实保存了T类型的值，那么t会获得该值，ok为true。
如果i中不是T类型的值，t会是T类型的零值，ok为false，但程序不会panic。

类型断言就像是打开盒子检查里面到底是什么。

简单形式(t := i.(T))就像是你确信盒子里装的是某样东西，直接拿出来用
安全形式(t, ok := i.(T))就像是你不确定盒子里是什么，所以先小心地看一眼，确认是你想要的东西再使用

以上面提供的代码示例：

 1var i interface{} = "hello"  // 创建一个接口变量i，存入字符串"hello"
 2
 3s := i.(string)  // 断言i中存储的是字符串，获取该字符串值
 4fmt.Println(s)   // 输出: "hello"
 5
 6s, ok := i.(string)  // 安全方式断言i中存储的是字符串
 7fmt.Println(s, ok)   // 输出: "hello true"
 8
 9f, ok := i.(float64)  // 安全方式断言i中存储的是float64
10fmt.Println(f, ok)    // 输出: "0 false"（断言失败，f得到float64的零值0，ok为false）
11
12f = i.(float64)  // 直接断言i中存储的是float64（但实际上不是）
13fmt.Println(f)   // 不会执行，因为上一行会触发panic

类型断言的安全形式（t, ok := i.(T)）语法与Go中读取映射的语法非常相似：

1value, exists := someMap[key]

两者都是返回两个值，第一个值是获取到的实际值（如果存在/断言成功），第二个值是一个布尔值，表示操作是否成功。

当我们需要访问接口值中存储的具体类型特有的方法或属性时，就需要使用类型断言将接口值"还原"为其原始类型。

类型选择

类型选择是一种按顺序从几个类型断言中选择分支的结构。与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值），它们针对给定接口值所存储的值的类型进行比较。

1switch v := i.(type) {
2    case T:
3        // v 的类型为 T
4    case S:
5        // v 的类型为 S
6    default:
7        // 没有匹配，v 与 i 的类型相同
8}

说人话：它可以查明一个接口变量里面藏着什么具体类型的值，然后根据不同类型执行不同的代码。

类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type。

此选择语句判断接口值 i 保存的值类型是 T 还是 S。在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。

 1package main
 2
 3import "fmt"
 4
 5func do(i interface{}) {
 6    switch v := i.(type) {
 7    case int:
 8        fmt.Printf("二倍的 %v 是 %v\n", v, v*2)
 9    case string:
10        fmt.Printf("%q 长度为 %v 字节\n", v, len(v))
11    default:
12        fmt.Printf("我不知道类型 %T!\n", v)
13    }
14}
15
16func main() {
17    do(21)
18    do("hello")
19    do(true)
20}

输出

二倍的 21 是 42
“hello” 长度为 5 字节
我不知道类型 bool!

普通的 switch：根据值来选择执行哪个分支
类型选择：根据类型来选择执行哪个分支

类型选择只能用于接口值，因为只有接口值才能容纳不同类型的数据。

Stringer

fmt 包中定义的 Stringer 是最普遍的接口之一。

1type Stringer interface {
2    String() string
3}

Stringer 是一个可以用字符串描述自己的类型。fmt 包（还有很多包）都通过此接口来打印值。

 1package main
 2
 3import "fmt"
 4
 5type Person struct {
 6    Name string
 7    Age  int
 8}
 9
10func (p Person) String() string {
11    return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
12}
13
14func main() {
15    a := Person{"Arthur Dent", 42}
16    z := Person{"Zaphod Beeblebrox", 9001}
17    fmt.Println(a, z) // output: Arthur Dent (42 years) Zaphod Beeblebrox (9001 years)
18}

练习：Stringer

通过让 IPAddr 类型实现 fmt.Stringer 来打印点号分隔的地址。

例如，IPAddr{1, 2, 3, 4} 应当打印为 "1.2.3.4"。

例题

 1package main
 2
 3import "fmt"
 4
 5type IPAddr [4]byte
 6
 7// TODO: 为 IPAddr 添加一个 "String() string" 方法。
 8
 9func main() {
10    hosts := map[string]IPAddr{
11        "loopback":  {127, 0, 0, 1},
12        "googleDNS": {8, 8, 8, 8},
13    }
14    for name, ip := range hosts {
15        fmt.Printf("%v: %v\n", name, ip)
16    }
17}

loopback: [127 0 0 1]
googleDNS: [8 8 8 8]

为 String() 类型添加了 IPAddr 方法，该方法可将 IP 地址格式化为以点分隔的字符串；
使用 fmt.Sprintf 将每个字节转换为十进制数，并用点将它们连接起来；
就能将 IPAddr{1, 2, 3, 4} 打印为 1.2.3.4，以标准点阵格式显示 IP 地址。

答案

 1package main
 2
 3import (
 4    "fmt"
 5)
 6
 7type IPAddr [4]byte
 8
 9// Add String method to implement fmt.Stringer interface
10func (ip IPAddr) String() string {
11    return fmt.Sprintf("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3])
12}
13
14func main() {
15    hosts := map[string]IPAddr{
16        "loopback":  {127, 0, 0, 1},
17        "googleDNS": {8, 8, 8, 8},
18    }
19    for name, ip := range hosts {
20        fmt.Printf("%v: %v\n", name, ip)
21    }
22}

loopback: 127.0.0.1
googleDNS: 8.8.8.8

错误

Go 程序使用 error 值来表示错误状态。与 fmt.Stringer 类似，error 类型是一个内建接口：

1type error interface {
2    Error() string
3}

与 fmt.Stringer 类似，fmt 包也会根据对 error 的实现来打印值。通常函数会返回一个 error 值，调用它的代码应当判断这个错误是否等于 nil 来进行错误处理。

1i, err := strconv.Atoi("42")
2if err != nil {
3    fmt.Printf("couldn't convert number: %v\n", err)
4    return
5}
6fmt.Println("Converted integer:", i)

error 为 nil 时表示成功；非 nil 的 error 表示失败。

 1package main
 2
 3import (
 4    "fmt"
 5    "time"
 6)
 7
 8type MyError struct {
 9    When time.Time
10    What string
11}
12
13func (e *MyError) Error() string {
14    return fmt.Sprintf("at %v, %s",
15        e.When, e.What)
16}
17
18func run() error {
19    return &MyError{
20        time.Now(),
21        "it didn't work",
22    }
23}
24
25func main() {
26    if err := run(); err != nil {
27        fmt.Println(err)
28    }
29}

输出

at 2009-11-10 23:00:00 +0000 UTC m=+0.000000001, it didn’t work

Readers

io 包指定了 io.Reader 接口，它表示数据流的读取端。Go 标准库包含了该接口的许多实现，包括文件、网络连接、压缩和加密等等。

io.Reader 接口有一个 Read 方法：func (T) Read(b []byte) (n int, err error)。Read 用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时，它会返回一个 io.EOF 错误。

示例代码创建了一个 strings.Reader 并以每次 8 字节的速度读取它的输出。

 1package main
 2
 3import (
 4    "fmt"
 5    "io"
 6    "strings"
 7)
 8
 9func main() {
10    r := strings.NewReader("Hello, Reader!")
11
12    b := make([]byte, 8)
13    for {
14        n, err := r.Read(b)
15        fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
16        fmt.Printf("b[:n] = %q\n", b[:n])
17        if err == io.EOF {
18            break
19        }
20    }
21}

输出

n = 8 err = b = [72 101 108 108 111 44 32 82]
b[:n] = “Hello, R”
n = 6 err = 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

实现一个 Reader 类型，它产生一个 ASCII 字符 'A' 的无限流。io.Reader 要求实现如下方法：

1Read(p []byte) (n int, err error)

例题

 1package main
 2
 3import "golang.org/x/tour/reader"
 4
 5type MyReader struct{}
 6
 7// TODO: 为 MyReader 添加一个 Read([]byte) (int, error) 方法。
 8
 9func main() {
10	reader.Validate(MyReader{})
11}

此方法要将数据写入切片 p，返回写入的字节数，和可能的错误。这里题目的要求是产生无限个字符 'A' 的流，所以你写多少就返回多少，全写成 'A' 就可以了，不需要返回 io.EOF。

答案

 1package main
 2
 3import "golang.org/x/tour/reader"
 4
 5type MyReader struct{}
 6
 7// 实现 Read 方法
 8func (r MyReader) Read(p []byte) (n int, err error) {
 9    // 填满 p，全部赋值为 'A'
10    for i := range p {
11        p[i] = 'A'
12    }
13    // 返回填充的长度，不报错
14    return len(p), nil
15}
16
17func main() {
18    reader.Validate(MyReader{})
19}

OK!

要点说明：

for i := range p { p[i] = 'A' } 保证每个元素都写成 'A'
返回值 len(p), nil，说明全部填充，没有出错
MyReader 是结构体，实现了 Read 方法，所以它就是 io.Reader

运行这段代码，reader.Validate 会测试你的实现是否正确。OK!

练习：rot13Reader

有种常见的模式是一个 io.Reader 包装另一个 io.Reader，然后通过某种方式修改其数据流。例如，gzip.NewReader 函数接受一个 io.Reader（已压缩的数据流）并返回一个同样实现了 io.Reader 的 *gzip.Reader（解压后的数据流）。

编写一个实现了 io.Reader 并从另一个 io.Reader 中读取数据的 rot13Reader，通过应用 rot13 代换密码对数据流进行修改。rot13Reader 类型已经提供。实现 Read 方法以满足 io.Reader。

ROT13 是一个简单的加密算法，它将每个字母向前移动13个位置。由于英文字母表有26个字母，所以应用 ROT13 两次会得到原文。这使得它既是加密算法也是解密算法。

例题

 1package main
 2
 3import (
 4	"io"
 5	"os"
 6	"strings"
 7)
 8
 9type rot13Reader struct {
10	r io.Reader
11}
12
13func main() {
14	s := strings.NewReader("Lbh penpxrq gur pbqr!")
15	r := rot13Reader{s}
16	io.Copy(os.Stdout, &r)
17}

其实就是要实现一个 rot13Reader 类型，包装另一个 io.Reader 并应用 ROT13 加密算法处理读取的数据。ROT13 是一种简单的字母替换密码，它将字母表中的每个字母替换为其后的第 13 个字母。

答案

 1package main
 2
 3import (
 4    "io"
 5    "os"
 6    "strings"
 7)
 8
 9type rot13Reader struct {
10    r io.Reader
11}
12
13func (r *rot13Reader) Read(p []byte) (n int, err error) {
14    n, err = r.r.Read(p)
15    for i := 0; i < n; i++ {
16        if p[i] >= 'A' && p[i] <= 'Z' {
17            p[i] = 'A' + (p[i]-'A'+13)%26
18        } else if p[i] >= 'a' && p[i] <= 'z' {
19            p[i] = 'a' + (p[i]-'a'+13)%26
20        }
21    }
22    return
23}
24
25func main() {
26    s := strings.NewReader("Lbh penpxrq gur pbqr!")
27    r := rot13Reader{s}
28    io.Copy(os.Stdout, &r)
29}

You cracked the code!

首先从被包装的 io.Reader 中读取数据到缓冲区 p
然后对读取到的每个字节应用 ROT13 变换:
- 对于大写字母 ('A'-'Z')，应用 ROT13 变换
- 对于小写字母 ('a'-'z')，应用 ROT13 变换
- 其他字符（如空格、标点符号等）保持不变

当程序运行时，它会将 Lbh penpxrq gur pbqr! 通过 ROT13 解码后输出 You cracked the code!

图像

image包定义了 Image 接口：

1package image
2type Image interface {
3    ColorModel() color.Model
4    Bounds() Rectangle
5    At(x, y int) color.Color
6}

注意: Bounds 方法的返回值 Rectangle 实际上是一个image.Rectangle，它在 image 包中声明。（请参阅文档了解全部信息。）

color.Color 和 color.Model 类型也是接口，但是通常因为直接使用预定义的实现 image.RGBA 和 image.RGBAModel 而被忽视了。这些接口和类型由 image/color 包定义。

 1package main
 2
 3import (
 4    "fmt"
 5    "image"
 6)
 7
 8func main() {
 9    m := image.NewRGBA(image.Rect(0, 0, 100, 100))
10    fmt.Println(m.Bounds())
11    fmt.Println(m.At(0, 0).RGBA())
12}

输出

(0,0)-(100,100)
0 0 0 0

练习：图像

还记得之前编写的图片生成器吗？我们再来编写另外一个，不过这次它将会返回一个 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}。

例题

 1package main
 2
 3import "golang.org/x/tour/pic"
 4
 5type Image struct{}
 6
 7func main() {
 8	m := Image{}
 9	pic.ShowImage(m)
10}

三步走：

定义一个 Image 类型
实现必要的 image.Image 接口方法
调用 pic.ShowImage 来展示图像

image.Image 接口需要实现三个方法:

Bounds() - 应当返回 image.Rectangle，例如 image.Rect(0, 0, w, h)
ColorModel() - 应当返回 color.RGBAModel
At(x, y int) - 应当返回一个颜色，将上一个图像生成器的值 v 转换为 color.RGBA{v, v, 255, 255}

答案

 1package main
 2
 3import (
 4    "image"
 5    "image/color"
 6    "golang.org/x/tour/pic"
 7)
 8
 9type Image struct{
10    width, height int
11}
12
13func (img Image) Bounds() image.Rectangle {
14    return image.Rect(0, 0, img.width, img.height)
15}
16
17func (img Image) ColorModel() color.Model {
18    return color.RGBAModel
19}
20
21func (img Image) At(x, y int) color.Color {
22    // 这里我们使用之前练习中类似的函数来生成颜色值
23    v := uint8((x + y) / 2)
24    // 返回颜色，将值v转换为color.RGBA{v, v, 255, 255}
25    return color.RGBA{v, v, 255, 255}
26}
27
28func main() {
29    m := Image{256, 256}  // 创建一个256x256的图像
30    pic.ShowImage(m)
31}

Bounds() 方法返回了图像的矩形边界，使用 image.Rect(0, 0, img.width, img.height)；
ColorModel() 方法返回了 color.RGBAModel，表示我们使用RGBA颜色模型；
At(x, y int) 方法根据坐标计算颜色值，将之前图像生成器的值 v 映射到 color.RGBA{v, v, 255, 255}，创建一个蓝色调的图像。

这个代码会生成一个渐变的蓝色图像，因为我们将 RGB 中的蓝色通道值设为了最大值 255，同时根据坐标计算的值来控制红色和绿色通道。你可以尝试不同的函数来计算 v 的值，例如 x*y、(x+y)/2、x^y 等，这会产生不同的图案效果。

泛型

类型参数

可以使用类型参数编写 Go 函数来处理多种类型，可以让你编写更加通用和可复用的代码。函数的类型参数出现在函数参数之前的方括号之间：func Index[T comparable](s []T, x T) int。此声明意味着 s 是满足内置约束 comparable 的任何类型 T 的切片。 x 也是相同类型的值。

comparable 是一个有用的约束，它能让我们对任意满足该类型的值使用 == 和 != 运算符。在此示例中，我们使用它将值与所有切片元素进行比较，直到找到匹配项。该 Index 函数适用于任何支持比较的类型。

 1package main
 2
 3import "fmt"
 4
 5// Index 返回 x 在 s 中的下标，未找到则返回 -1。
 6func Index[T comparable](s []T, x T) int {
 7	for i, v := range s {
 8		// v 和 x 的类型为 T，它拥有 comparable 可比较的约束，
 9		// 因此我们可以使用 ==。
10		if v == x {
11			return i
12		}
13	}
14	return -1
15}
16
17func main() {
18	// Index 可以在整数切片上使用
19	si := []int{10, 20, 15, -10}
20	fmt.Println(Index(si, 15))
21
22	// Index 也可以在字符串切片上使用
23	ss := []string{"foo", "bar", "baz"}
24	fmt.Println(Index(ss, "hello"))
25}

输出

2
-1

类型参数就像是给函数的"类型"留了一个空位，等到真正使用时再填入具体的类型。这样一个函数就能适用于多种数据类型，避免了对于每种不同类型，都需要复制并修改相似的代码的情况。

func Index[T comparable](s []T, x T) int 里的 [T comparable] 可以理解为：

T 是一个"占位符"，表示某种具体的类型
comparable 是一个约束，表示 T 必须是可以用 == 比较的类型 [[2]]

这个 Index 函数可以接受任何类型的切片和相同类型的单个值，并返回该值在切片中的位置（找不到则返回 -1）。

当你调用 Index([]int{10, 20, 15}, 15) 时，Go 会自动将 T 理解为 int 类型。当你调用 Index([]string{"foo", "bar"}, "bar") 时，Go 会自动将 T 理解为 string 类型。

泛型类型

除了泛型函数之外，Go 还支持泛型类型。类型可以使用类型参数进行参数化，这对于实现通用数据结构非常有用，能够保存任意类型值的单链表的简单类型声明。
下面是一个练习，请为此链表的实现添加一些功能。

例题

 1package main
 2
 3// List 表示一个可以保存任何类型的值的单链表。
 4type List[T any] struct {
 5	next *List[T]
 6	val  T
 7}
 8
 9func main() {
10}

Go 从 1.18 版开始增加了对泛型（类型参数）的支持。通过泛型，可以编写适用于多种类型的代码，这对于实现像链接列表这样的泛型数据结构尤其有用。

答案

  1package main
  2
  3import "fmt"
  4
  5// List represents a single linked list that can store values of any type.
  6type List[T any] struct {
  7	next *List[T]
  8	val  T
  9}
 10
 11// NewList creates a new list with the given value.
 12func NewList[T any](val T) *List[T] {
 13	return &List[T]{val: val}
 14}
 15
 16// PushFront adds a new element to the beginning of the list.
 17func (l *List[T]) PushFront(val T) *List[T] {
 18	newHead := &List[T]{
 19		next: l,
 20		val:  val,
 21	}
 22	return newHead
 23}
 24
 25// Append adds a new element to the end of the list.
 26func (l *List[T]) Append(val T) *List[T] {
 27	if l == nil {
 28		return NewList(val)
 29	}
 30	
 31	current := l
 32	for current.next != nil {
 33		current = current.next
 34	}
 35	current.next = &List[T]{val: val}
 36	return l
 37}
 38
 39// Print displays all elements in the list.
 40func (l *List[T]) Print() {
 41	if l == nil {
 42		fmt.Println("Empty list")
 43		return
 44	}
 45	
 46	current := l
 47	for current != nil {
 48		fmt.Printf("%v -> ", current.val)
 49		current = current.next
 50	}
 51	fmt.Println("nil")
 52}
 53
 54// Length returns the number of elements in the list.
 55func (l *List[T]) Length() int {
 56	count := 0
 57	current := l
 58	for current != nil {
 59		count++
 60		current = current.next
 61	}
 62	return count
 63}
 64
 65// Contains checks if a value exists in the list.
 66// This requires that T supports the comparable constraint.
 67func Contains[T comparable](l *List[T], val T) bool {
 68	current := l
 69	for current != nil {
 70		if current.val == val {
 71			return true
 72		}
 73		current = current.next
 74	}
 75	return false
 76}
 77
 78// RemoveFirst removes the first occurrence of a value.
 79// This also requires that T supports the comparable constraint.
 80func RemoveFirst[T comparable](l *List[T], val T) *List[T] {
 81	if l == nil {
 82		return nil
 83	}
 84	
 85	// If head has the value to remove
 86	if l.val == val {
 87		return l.next
 88	}
 89	
 90	// Search for the value in subsequent nodes
 91	current := l
 92	for current.next != nil {
 93		if current.next.val == val {
 94			current.next = current.next.next
 95			break
 96		}
 97		current = current.next
 98	}
 99	
100	return l
101}
102
103func main() {
104	// Create a list of integers
105	intList := NewList(1)
106	intList = intList.Append(2)
107	intList = intList.Append(3)
108	intList = intList.PushFront(0)
109	
110	fmt.Println("Integer list:")
111	intList.Print()
112	fmt.Printf("List length: %d\n", intList.Length())
113	fmt.Printf("Contains 2: %v\n", Contains(intList, 2))
114	
115	// Remove an element
116	intList = RemoveFirst(intList, 2)
117	fmt.Println("After removing 2:")
118	intList.Print()
119	
120	// Create a list of strings
121	strList := NewList("hello")
122	strList = strList.Append("world")
123	strList = strList.Append("go")
124	
125	fmt.Println("\nString list:")
126	strList.Print()
127}

Integer list:
0 -> 1 -> 2 -> 3 -> nil
List length: 4
Contains 2: true
After removing 2:
0 -> 1 -> 3 -> nil

String list:
hello -> world -> go -> nil

NewList 用初始值创建一个新列表， PushFront 将元素添加到开头（O(1) 运算）， Append 在末尾添加元素（O(n) 运算）， Print 显示列表中的所有元素， Length 计算元素个数， Contains 检查列表中是否存在值， RemoveFirst 移除数值的第一次出现。

Contains 和 RemoveFirst 函数要求类型参数 T 是 可比较的 ，这意味着可以使用 == 和 !=。有些操作是作为独立函数而不是方法实现的，因为它们需要额外的类型约束，而这些约束并不是原始结构体定义的一部分。该实现维护了链表结构，每次操作都会在需要时返回新的表头，这是链表操作的常见模式。

小记

终于快把基础的学完了。当然，仅仅看代码没有用，还是要自己写点东西或者找点项目搞一下，不然始终就是纸上谈兵。