# 第四章：函数与接口 —— 代码复用与多态

> **本章目标**：深入理解 Go 的函数式编程特性（闭包、匿名函数）、defer 机制、错误处理、panic/recover，以及接口的底层实现原理和最佳实践。

## 4.1 函数基础回顾与深度解析

### 4.1.1 函数声明与调用

```go
package main

import "fmt"

// 基本函数
func add(a int, b int) int {
    return a + b
}

// 省略参数类型（连续同类型）
func addShort(a, b int) int {
    return a + b
}

// 多个返回值
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

// 命名返回值
func divideNamed(a, b float64) (result float64, err error) {
    if b == 0 {
        err = fmt.Errorf("除数不能为零")
        return // 返回命名返回值
    }
    result = a / b
    return // 返回命名返回值
}

func main() {
    fmt.Println(add(3, 4))
    fmt.Println(addShort(3, 4))
    
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Printf("10 / 2 = %.2f\n", result)
    }
    
    result2, _ := divideNamed(20, 4)
    fmt.Printf("20 / 4 = %.2f\n", result2)
}
```

**深度解析**：
- **命名返回值**：适合返回值较多或需要明确语义的场景
- **省略类型**：仅适用于连续的同类型参数
- **多返回值**：Go 的特色，常用于返回结果 + 错误

### 4.1.2 可变参数

```go
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

func printArgs(prefix string, args ...interface{}) {
    fmt.Printf("%s: ", prefix)
    for _, arg := range args {
        fmt.Printf("%v ", arg)
    }
    fmt.Println()
}

func main() {
    fmt.Println(sum(1, 2, 3, 4, 5))  // 15
    fmt.Println(sum())                // 0
    
    // 切片展开
    nums := []int{10, 20, 30}
    fmt.Println(sum(nums...))         // 60
    
    printArgs("参数", 1, "hello", 3.14, true)
}
```

**深度解析**：
- `...T` 表示可变参数，在函数内部被视为**切片**
- 调用时可以用 `...` 展开切片
- 可变参数必须是**最后一个参数**

---

## 4.2 匿名函数与闭包

### 4.2.1 匿名函数

```go
func anonymousFunc() {
    // 定义匿名函数
    func() {
        fmt.Println("这是一个匿名函数")
    }()  // 立即调用
    
    // 赋值给变量
    multiply := func(a, b int) int {
        return a * b
    }
    fmt.Println(multiply(3, 4))  // 12
    
    // 作为参数传递
    apply := func(f func(int, int) int, x, y int) int {
        return f(x, y)
    }
    fmt.Println(apply(add, 5, 6))  // 11
}
```

### 4.2.2 闭包（Closure）⭐ 核心重点

闭包是**引用了外部变量的匿名函数**。闭包不仅包含函数本身，还包含其**创建时的环境**。

```go
func closureExample() {
    // 创建计数器
    counter := func() func() int {
        count := 0
        return func() int {
            count++
            return count
        }
    }
    
    c1 := counter()
    c2 := counter()
    
    fmt.Println(c1())  // 1
    fmt.Println(c1())  // 2
    fmt.Println(c1())  // 3
    fmt.Println(c2())  // 1（独立的 count）
    fmt.Println(c1())  // 4
}
```

**深度解析**：
- 闭包**捕获变量**而非值：内部函数引用的是外部变量的**引用**
- 每次调用 `counter()` 都会创建**新的 `count` 变量**
- 闭包的生命周期**长于**外部函数

### 4.2.3 闭包的陷阱

#### 陷阱 1：循环中的闭包

```go
func closureLoopBug() {
    funcs := make([]func(), 3)
    
    for i := 0; i < 3; i++ {
        funcs[i] = func() {
            fmt.Println(i)  // 捕获的是 i 的引用
        }
    }
    
    for _, f := range funcs {
        f()  // 输出：3 3 3（循环结束后的 i 值）
    }
}

// 正确做法
func closureLoopFix() {
    funcs := make([]func(), 3)
    
    for i := 0; i < 3; i++ {
        i := i  // 创建新的变量
        funcs[i] = func() {
            fmt.Println(i)
        }
    }
    
    for _, f := range funcs {
        f()  // 输出：0 1 2
    }
}

// 或者使用参数
func closureLoopFix2() {
    funcs := make([]func(), 3)
    
    for i := 0; i < 3; i++ {
        funcs[i] = func(n int) {
            fmt.Println(n)
        }(i)
    }
    
    for _, f := range funcs {
        f()  // 输出：0 1 2
    }
}
```

#### 陷阱 2：闭包内存泄漏

```go
func closureMemoryLeak() {
    largeData := make([]byte, 1024*1024)  // 1MB
    
    smallFunc := func() {
        fmt.Println(len(largeData))
    }
    
    // 即使 largeData 不再需要，只要 smallFunc 存在，largeData 就不会被回收
    _ = smallFunc
}
```

**最佳实践**：
- 如果闭包不需要引用大对象，避免捕获
- 使用 `func(n int)` 参数传递值而非捕获引用

### 4.2.4 闭包的实战应用

#### 1. 工厂函数

```go
func createMultiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    double := createMultiplier(2)
    triple := createMultiplier(3)
    
    fmt.Println(double(5))  // 10
    fmt.Println(triple(5))  // 15
}
```

#### 2. 中间件模式

```go
type Handler func(string) string

func loggingMiddleware(next Handler) Handler {
    return func(input string) string {
        fmt.Printf("处理：%s\n", input)
        result := next(input)
        fmt.Printf("结果：%s\n", result)
        return result
    }
}

func process(input string) string {
    return "处理完成：" + input
}

func main() {
    handler := loggingMiddleware(process)
    handler("测试数据")
}
```

---

## 4.3 defer 机制

### 4.3.1 基本用法

```go
func deferExample() {
    fmt.Println("开始")
    defer fmt.Println("延迟 1")
    defer fmt.Println("延迟 2")
    fmt.Println("结束")
}
// 输出：
// 开始
// 结束
// 延迟 2
// 延迟 1
```

**深度解析**：
- `defer` 语句**立即执行**，但函数调用**延迟到外层函数返回前**
- 多个 `defer` 按**后进先出（LIFO）** 顺序执行
- 常用于资源清理（文件关闭、锁释放、数据库连接）

### 4.3.2 defer 参数求值时机

```go
func deferArgs() {
    i := 0
    defer fmt.Println("i =", i)  // i 在 defer 时求值
    i = 10
    // 输出：i = 0
}

func deferArgs2() {
    i := 0
    defer func() {
        fmt.Println("i =", i)  // i 在函数执行时求值
    }()
    i = 10
    // 输出：i = 10
}
```

**深度解析**：
- 普通函数调用的参数在 `defer` 时**立即求值**
- 闭包的变量在闭包**执行时求值**

### 4.3.3 defer 的返回值修改

```go
func deferReturn() (result int) {
    defer func() {
        result += 10  // 修改命名返回值
    }()
    result = 5
    return  // 返回 15
}

func deferReturn2() int {
    defer func() {
        // 无法修改返回值（无名）
    }()
    return 5
}
```

### 4.3.4 常见陷阱

#### 陷阱 1：在循环中使用 defer

```go
func deferLoopBug() {
    for i := 0; i < 10; i++ {
        f, _ := os.Open("file.txt")
        defer f.Close()  // 所有 defer 在函数结束时执行
        // 文件描述符可能耗尽
    }
}

// 正确做法
func deferLoopFix() {
    for i := 0; i < 10; i++ {
        func() {
            f, _ := os.Open("file.txt")
            defer f.Close()
            // 使用 f
        }()  // 立即返回，defer 执行
    }
}
```

#### 陷阱 2：defer 掩盖错误

```go
func deferError() (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic: %v", r)
        }
    }()
    
    panic("出错了")
    return nil
}
```

---

## 4.4 panic 与 recover

### 4.4.1 panic 基础

```go
func panicExample() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获 panic:", r)
        }
    }()
    
    fmt.Println("开始")
    panic("发生错误")
    fmt.Println("不会执行")
}
```

**深度解析**：
- `panic` 立即停止当前函数，开始**栈展开**
- `recover` 必须在 `defer` 中调用才能捕获 panic
- panic 会**终止程序**，除非被 recover 捕获

### 4.4.2 使用场景

#### 1. 不可恢复的错误

```go
func divide(a, b int) int {
    if b == 0 {
        panic("除数不能为零")  // 编程错误，应该避免
    }
    return a / b
}

// 正确做法：返回错误
func divideSafe(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}
```

#### 2. 初始化失败

```go
var config *Config

func init() {
    c, err := loadConfig()
    if err != nil {
        panic(fmt.Sprintf("加载配置失败：%v", err))
    }
    config = c
}
```

### 4.4.3 自定义 panic 类型

```go
type MyError struct {
    Code    int
    Message string
}

func (e MyError) Error() string {
    return fmt.Sprintf("错误码 %d: %s", e.Code, e.Message)
}

func safeDivide(a, b int) (int, error) {
    if b == 0 {
        panic(MyError{Code: 1001, Message: "除数不能为零"})
    }
    return a / b, nil
}

func handlePanic() {
    defer func() {
        if r := recover(); r != nil {
            if err, ok := r.(MyError); ok {
                fmt.Printf("自定义错误：%v\n", err)
            } else {
                fmt.Printf("未知 panic: %v\n", r)
            }
        }
    }()
    
    safeDivide(10, 0)
}
```

---

## 4.5 接口（Interfaces）

### 4.5.1 接口定义与实现

```go
type Speaker interface {
    Speak() string
}

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + " 汪汪叫"
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return c.Name + " 喵喵叫"
}

func makeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{Name: "旺财"}
    cat := Cat{Name: "咪咪"}
    
    makeSound(dog)  // 旺财 汪汪叫
    makeSound(cat)  // 咪咪 喵喵叫
}
```

**深度解析**：
- 接口是**隐式实现**：不需要 `implements` 关键字
- 只要类型实现了接口的所有方法，就**自动实现**该接口
- 接口变量可以存储**任何实现该接口的类型**

### 4.5.2 空接口

```go
func printAny(v interface{}) {
    fmt.Println(v)
}

// Go 1.18+ 可以使用 any（interface{}的别名）
func printAny2(v any) {
    fmt.Println(v)
}

func main() {
    printAny(1)
    printAny("hello")
    printAny(3.14)
    printAny([]int{1, 2, 3})
}
```

### 4.5.3 类型断言

```go
func typeAssertion() {
    var v interface{} = "hello"
    
    // 基本断言
    s := v.(string)
    fmt.Println(s)
    
    // 安全断言
    if n, ok := v.(int); ok {
        fmt.Println(n)
    } else {
        fmt.Println("不是 int 类型")
    }
    
    // 类型开关
    switch t := v.(type) {
    case int:
        fmt.Printf("整数：%d\n", t)
    case string:
        fmt.Printf("字符串：%s\n", t)
    case float64:
        fmt.Printf("浮点数：%.2f\n", t)
    default:
        fmt.Printf("未知类型：%T\n", t)
    }
}
```

### 4.5.4 接口的底层实现

**深度解析**：
Go 的接口在底层由两个字段组成：
- `data`：指向实际数据的指针
- `type`：类型的描述信息（`_type`）

```go
// 接口底层结构（伪代码）
type iface struct {
    tab  *itab  // 接口表：包含类型和方法
    data unsafe.Pointer
}

type itab struct {
    inter  *interfacetype  // 接口类型
    _type  *_type          // 具体类型
    hash   uint32          // 类型哈希
    fun    [1]unsafe.Pointer  // 方法表
}
```

**空接口**（`interface{}`）：
- 所有类型都实现空接口
- 底层是 `eface` 结构

```go
type eface struct {
    _type *_type
    data  unsafe.Pointer
}
```

### 4.5.5 接口最佳实践

#### 1. 小接口优于大接口

```go
// 错误：接口太大
type BigInterface interface {
    Read() []byte
    Write([]byte) (int, error)
    Close() error
    Seek(int64, int) (int64, error)
    // ... 很多方法
}

// 正确：拆分为小接口
type Reader interface {
    Read() []byte
}

type Writer interface {
    Write([]byte) (int, error)
}

type Closer interface {
    Close() error
}

// 组合接口
type ReadWriter interface {
    Reader
    Writer
}
```

#### 2. 接口定义在使用者一侧

```go
// 错误：在定义者一侧定义接口
type Dog struct{}
func (d Dog) Speak() string { return "汪汪" }

// 在别处定义接口
type Speaker interface {
    Speak() string
}

// 正确：在使用者一侧定义
func process(s Speaker) {
    fmt.Println(s.Speak())
}

// Dog 自动实现 Speaker
```

#### 3. 避免过度抽象

```go
// 错误：不必要的接口
type Logger interface {
    Log(string)
}

type FileLogger struct{}
func (f FileLogger) Log(msg string) {
    fmt.Println("File:", msg)
}

func useLogger(l Logger) {
    l.Log("test")
}

// 正确：直接使用具体类型（如果不需要多态）
func useLogger2(l FileLogger) {
    l.Log("test")
}
```

---

## 4.6 深度实践：综合案例

### 4.6.1 插件系统

```go
type Plugin interface {
    Name() string
    Run() error
}

type HelloPlugin struct{}

func (h HelloPlugin) Name() string {
    return "HelloPlugin"
}

func (h HelloPlugin) Run() error {
    fmt.Println("Hello from plugin!")
    return nil
}

type MathPlugin struct{}

func (m MathPlugin) Name() string {
    return "MathPlugin"
}

func (m MathPlugin) Run() error {
    fmt.Printf("2 + 2 = %d\n", 2+2)
    return nil
}

func loadPlugins() []Plugin {
    return []Plugin{
        HelloPlugin{},
        MathPlugin{},
    }
}

func main() {
    plugins := loadPlugins()
    for _, p := range plugins {
        fmt.Printf("加载插件：%s\n", p.Name())
        if err := p.Run(); err != nil {
            fmt.Println("插件运行失败:", err)
        }
    }
}
```

### 4.6.2 中间件链

```go
type Middleware func(Handler) Handler
type Handler func(string) string

func logging(next Handler) Handler {
    return func(input string) string {
        fmt.Printf("[LOG] 输入：%s\n", input)
        result := next(input)
        fmt.Printf("[LOG] 输出：%s\n", result)
        return result
    }
}

func timing(next Handler) Handler {
    return func(input string) string {
        start := time.Now()
        result := next(input)
        fmt.Printf("[TIME] 耗时：%v\n", time.Since(start))
        return result
    }
}

func auth(next Handler) Handler {
    return func(input string) string {
        if input == "" {
            return "错误：空输入"
        }
        return next(input)
    }
}

func businessLogic(input string) string {
    return "处理结果：" + input
}

func main() {
    // 构建中间件链
    handler := auth(timing(logging(businessLogic)))
    
    result := handler("测试数据")
    fmt.Println("最终结果:", result)
}
```

### 4.6.3 错误处理链

```go
type AppError struct {
    Code    int
    Message string
    Cause   error
}

func (e *AppError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("错误码 %d: %s (原因：%v)", e.Code, e.Message, e.Cause)
    }
    return fmt.Sprintf("错误码 %d: %s", e.Code, e.Message)
}

func wrapError(err error, code int, message string) error {
    if err == nil {
        return nil
    }
    return &AppError{
        Code:    code,
        Message: message,
        Cause:   err,
    }
}

func readFile(path string) ([]byte, error) {
    // 模拟读取失败
    return nil, fmt.Errorf("文件不存在")
}

func processFile(path string) error {
    data, err := readFile(path)
    if err != nil {
        return wrapError(err, 1001, "读取文件失败")
    }
    
    // 处理数据
    if len(data) == 0 {
        return wrapError(nil, 1002, "文件为空")
    }
    
    return nil
}

func main() {
    err := processFile("test.txt")
    if err != nil {
        if appErr, ok := err.(*AppError); ok {
            fmt.Printf("应用错误：代码=%d, 消息=%s\n", appErr.Code, appErr.Message)
            if appErr.Cause != nil {
                fmt.Printf("根本原因：%v\n", appErr.Cause)
            }
        } else {
            fmt.Println("未知错误:", err)
        }
    }
}
```

---

## 4.7 常见陷阱与最佳实践

### 4.7.1 闭包陷阱总结

1. **循环变量捕获**：循环中使用闭包时，变量会共享
2. **内存泄漏**：闭包捕获大对象导致无法回收
3. **延迟求值**：注意 defer 中参数的求值时机

### 4.7.2 defer 陷阱总结

1. **循环中 defer**：可能导致资源耗尽
2. **返回值修改**：只能修改命名返回值
3. **掩盖错误**：recover 可能掩盖真正的 bug

### 4.7.3 接口陷阱总结

1. **空接口滥用**：过度使用 `interface{}` 失去类型安全
2. **接口过大**：定义太多方法的接口难以实现
3. **值 vs 指针**：值类型实现接口，指针类型不实现（反之亦然）

```go
type S struct{}
func (s S) Method() {}

var _ interface{ Method() } = S{}      // 正确
var _ interface{ Method() } = &S{}     // 正确
// var _ interface{ Method() } = (*S)(nil)  // 错误：nil 指针不实现
```

### 4.7.4 最佳实践

1. **优先使用错误返回**：panic 仅用于不可恢复错误
2. **小接口**：定义最小必要的接口方法
3. **闭包谨慎**：避免捕获大对象，循环中注意变量作用域
4. **defer 适度**：仅在需要清理资源时使用
5. **类型断言安全**：使用 `ok` 模式避免 panic

---

## 4.8 课后练习

1. **闭包计数器**：实现一个支持 `increment()`、`decrement()`、`reset()` 的计数器
2. **中间件框架**：实现一个简单的 HTTP 中间件框架
3. **错误包装**：实现一个支持错误链包装的工具函数
4. **接口组合**：设计一组小接口，组合成复杂功能
5. **defer 测试**：编写测试验证 defer 的执行顺序和参数求值时机

## 4.9 下一步

完成本章后，你将进入第五章：**并发编程**，深入学习 Go 最强大的特性——Goroutine 和 Channel，以及并发模式、同步原语和并发最佳实践。

---

**代码仓库位置**：https://giter.top/openclaw/test/tree/main/chapters/chapter-4

**下一章预告**：Goroutine 原理、Channel 通信模式、sync 包、并发设计模式、竞态检测