3.Go 接口

1
// 定义接口
2
type Writer interface {
3
    Write(p []byte) (n int, err error)
4
}
5

6
// 定义结构体
7
type MyWriter struct{}
8

9
// 实现 Write 方法 - 隐式实现了 Writer 接口
10
func (m MyWriter) Write(p []byte) (n int, err error) {
11
    return len(p), nil
12
}
13

14
// 使用 - 不需要显式声明 implements
15
var w Writer = MyWriter{} // 自动匹配，编译通过

1
// 1. 函数接收任意类型参数（fmt 包的核心设计）
2
func Printf(format string, a ...interface{})
3
func Println(a ...interface{})
4

5
// 2. 存储任意类型的数据
6
var m = map[string]interface{}{
7
    "name":   "张三",
8
    "age":    25,
9
    "scores": []int{90, 85, 88},
10
}
11

12
// 3. 泛型出现之前的"泛型"方案
13
type Container struct {
14
    data []interface{}
15
}
16

17
// 4. 反射操作的基础
18
func TypeOf(i interface{}) reflect.Type
19
func ValueOf(i interface{}) reflect.Value

1
var p *int = nil
2
var i interface{} = p  // i 不是 nil！它是一个包含 nil 指针的非 nil 接口！
3

4
fmt.Println(i == nil)  // false！
5
fmt.Println(i == (*int)(nil))  // true，需要比较具体类型
6

7
// 危险场景
8
func IsNil(v interface{}) bool {
9
    return v == nil  // 错误！无法判断内部的 nil
10
}
11

12
// 正确做法：配合反射
13
func IsReallyNil(v interface{}) bool {
14
    if v == nil {
15
        return true
16
    }
17
    rv := reflect.ValueOf(v)
18
    switch rv.Kind() {
19
    case reflect.Ptr, reflect.Slice, reflect.Map,
20
         reflect.Chan, reflect.Func, reflect.Interface:
21
        return rv.IsNil()
22
    }
23
    return false
24
}

1
// 形式1：直接断言（失败会 panic）
2
x.(T)
3

4
// 形式2：安全断言（ok-idiom，推荐）
5
value, ok := x.(T)
6

7
// 形式3：类型选择（switch 形式）
8
switch v := x.(type) {
9
case T1:
10
    // v 的类型是 T1
11
case T2:
12
    // v 的类型是 T2
13
default:
14
    // v 的类型是 x 的原始接口类型
15
}

1
var x interface{} = "hello"
2

3
// 安全断言
4
s, ok := x.(string)
5
if ok {
6
    fmt.Printf("string: %q, length: %d\\n", s, len(s))
7
}
8

9
// 直接断言（确信类型时使用）
10
s2 := x.(string)  // 成功
11

12
// 错误断言会 panic
13
// n := x.(int)  // panic: interface conversion: interface {} is string, not int
14

15
// 类型选择
16
func describe(i interface{}) string {
17
    switch v := i.(type) {
18
    case int:
19
        return fmt.Sprintf("int %d", v)
20
    case string:
21
        return fmt.Sprintf("string %q (len=%d)", v, len(v))
22
    case []int:
23
        return fmt.Sprintf("slice with %d elements", len(v))
24
    case nil:
25
        return "nil interface"
26
    default:
27
        return fmt.Sprintf("unknown type %T", v)
28
    }
29
}

1
// 方式1：errors.New - 简单静态错误
2
var ErrNotFound = errors.New("not found")
3

4
// 方式2：fmt.Errorf - 格式化错误
5
err := fmt.Errorf("user %s not found", name)
6

7
// 方式3：fmt.Errorf + %w 包装错误（Go 1.13+）
8
err := fmt.Errorf("operation failed: %w", originalErr)
9

10
// 方式4：自定义错误类型
11
type ValidationError struct {
12
    Field   string
13
    Message string
14
}
15

16
func (e *ValidationError) Error() string {
17
    return fmt.Sprintf("validation error on %s: %s", e.Field, e.Message)
18
}

1
v, ok := x.(int)  // 拆箱
2

3
// 底层逻辑（伪代码）：
4
func unbox(e eface, target *_type) (unsafe.Pointer, bool) {
5
    // 1. 类型匹配检查（关键！）
6
    if e._type != target {
7
        // 还需检查是否实现了目标接口（接口断言时）
8
        return nil, false
9
    }
10

11
    // 2. 提取数据
12
    if directStore(e._type.size) {
13
        return &e.data, true  // 小值直接从 data 域提取
14
    }
15
    return e.data, true       // 大值从 data 指向的地址提取
16
}

1
// ===== 反模式：频繁装箱拆箱 =====
2
func SumAny(values []interface{}) int {
3
    total := 0
4
    for _, v := range values {
5
        total += v.(int)  // 每次循环都拆箱！
6
    }
7
    return total
8
}
9

10
// ===== 优化：使用具体类型 =====
11
func SumInt(values []int) int {
12
    total := 0
13
    for _, v := range values {
14
        total += v  // 直接操作，零额外开销
15
    }
16
    return total
17
}
18

19
// ===== 优化：泛型（Go 1.18+）=====
20
func SumGeneric[T ~int | ~int64](values []T) T {
21
    var total T
22
    for _, v := range values {
23
        total += v
24
    }
25
    return total
26
}
27

28
// ===== 优化：避免大值装箱的堆分配 =====
29
type Point struct { X, Y float64 }
30

31
// 差：值接收者，大结构体复制+可能堆分配
32
func (p Point) ToInterface() interface{} {
33
    return p
34
}
35

36
// 好：指针接收者，只复制指针
37
func (p *Point) ToInterface() interface{} {
38
    return p  // 8字节指针，无大值拷贝
39
}

1
package main
2

3
import (
4
    "errors"
5
    "fmt"
6
    "reflect"
7
    "unsafe"
8
)
9

10
// ========== 接口定义 ==========
11
type Animal interface {
12
    Speak() string
13
}
14

15
// ========== 隐式实现 ==========
16
type Dog struct{ Name string }
17
func (d Dog) Speak() string { return "Woof!" }
18

19
type Cat struct{ Name string }
20
func (c Cat) Speak() string { return "Meow!" }
21

22
// ========== 自定义 error ==========
23
type NotFoundError struct {
24
    Resource string
25
    ID       int
26
}
27
func (e *NotFoundError) Error() string {
28
    return fmt.Sprintf("%s(id=%d) not found", e.Resource, e.ID)
29
}
30

31
// ========== 使用空接口 + 类型断言 ==========
32
func Describe(v interface{}) (string, error) {
33
    // 类型选择：拆箱操作
34
    switch x := v.(type) {
35
    case Animal:
36
        // 接口断言：拆箱为另一个接口
37
        return fmt.Sprintf("Animal: %s", x.Speak()), nil
38
    case string:
39
        return fmt.Sprintf("String: %q", x), nil
40
    case int, int64, float64:
41
        // 利用反射处理数值类型（避免重复代码）
42
        rv := reflect.ValueOf(v)
43
        return fmt.Sprintf("Number: %v", rv.Interface()), nil
44
    case error:
45
        // error 也是接口，可进一步拆箱
46
        if nfe, ok := x.(*NotFoundError); ok {
47
            return "", fmt.Errorf("not found: %w", nfe)
48
        }
49
        return "", x
50
    case nil:
51
        return "", errors.New("nil value")
52
    default:
53
        return "", fmt.Errorf("unsupported type: %T", v)
54
    }
55
}
56

57
// ========== 查看底层结构 ==========
58
func inspectInterface(i interface{}) {
59
    // 利用 unsafe 查看 eface 结构
60
    e := (*[2]unsafe.Pointer)(unsafe.Pointer(&i))
61
    fmt.Printf("  _type: %p\\n", e[0])
62
    fmt.Printf("  data:  %p (value: ", e[1])
63

64
    // 安全打印值
65
    rv := reflect.ValueOf(i)
66
    if rv.Kind() == reflect.Ptr && rv.IsNil() {
67
        fmt.Println("nil pointer)")
68
    } else {
69
        fmt.Printf("%v)\\n", i)
70
    }
71
}
72

73
func main() {
74
    fmt.Println("=== 隐式实现 ===")
75
    var animals []Animal = []Animal{Dog{"Buddy"}, Cat{"Kitty"}}
76
    for _, a := range animals {
77
        fmt.Println(a.Speak())
78
    }
79

80
    fmt.Println("\\n=== 空接口装箱 ===")
81
    var i1 interface{} = 42
82
    var i2 interface{} = "hello"
83
    var i3 interface{} = []int{1, 2, 3}
84

85
    fmt.Println("int 装箱:")
86
    inspectInterface(i1)
87
    fmt.Println("string 装箱:")
88
    inspectInterface(i2)
89
    fmt.Println("slice 装箱:")
90
    inspectInterface(i3)
91

92
    fmt.Println("\\n=== 类型断言拆箱 ===")
93
    if v, ok := i1.(int); ok {
94
        fmt.Printf("拆箱 int: %d\\n", v)
95
    }
96

97
    // 错误拆箱
98
    if _, ok := i1.(string); !ok {
99
        fmt.Println("int 不能拆箱为 string")
100
    }
101

102
    fmt.Println("\\n=== error 接口使用 ===")
103
    err := &NotFoundError{"User", 100}
104
    result, e := Describe(err)
105
    fmt.Printf("result=%q, err=%v\\n", result, e)
106

107
    fmt.Println("\\n=== 综合 Describe ===")
108
    tests := []interface{}{
109
        Dog{"Rex"},
110
        42,
111
        "hello",
112
        nil,
113
        []float64{1.1, 2.2},
114
    }
115
    for _, t := range tests {
116
        r, e := Describe(t)
117
        if e != nil {
118
            fmt.Printf("%T -> ERROR: %v\\n", t, e)
119
        } else {
120
            fmt.Printf("%T -> %s\\n", t, r)
121
        }
122
    }
123
}