编辑“︁Go 函数链”︁（章节）

= Go函数链 =

'''Go函数链'''（Function Chaining）是一种函数式编程技术，通过将多个函数按顺序连接起来，将一个函数的输出作为下一个函数的输入，从而构建清晰、可组合的数据处理流程。在Go语言中，虽然原生不支持函数式编程的高阶特性（如柯里化或惰性求值），但通过闭包和接口设计，仍能实现优雅的函数链式调用。

== 基本概念 ==

函数链的核心思想是：每个函数接收一个输入值，处理后返回一个新值，该值可直接传递给链中的下一个函数。这种模式常见于数据处理、流式API设计和构建器模式中。

数学上可表示为：
<math>
f_n \circ \dots \circ f_2 \circ f_1(x) = f_n(\dots(f_2(f_1(x))))
</math>

=== 特点 ===
* '''可读性'''：链式调用将操作步骤线性化
* '''无状态'''：每个函数不修改原始数据，返回新结果
* '''组合性'''：函数可自由替换或重组

== 基础实现 ==

以下是Go中实现函数链的两种典型方式：

=== 方法链 ===
通过结构体方法返回自身指针实现链式调用：

<syntaxhighlight lang="go">
type FilterChain struct {
    data []int
}

func (f *FilterChain) Filter(fn func(int) bool) *FilterChain {
    var result []int
    for _, v := range f.data {
        if fn(v) {
            result = append(result, v)
        }
    }
    f.data = result
    return f
}

// 使用示例
chain := &FilterChain{data: []int{1, 2, 3, 4, 5}}
result := chain.
    Filter(func(x int) bool { return x > 2 }).
    Filter(func(x int) bool { return x%2 == 0 }).
    data
fmt.Println(result) // 输出: [4]
</syntaxhighlight>

=== 函数组合 ===
通过高阶函数实现纯函数链：

<syntaxhighlight lang="go">
func Map(nums []int, fn func(int) int) []int {
    var result []int
    for _, v := range nums {
        result = append(result, fn(v))
    }
    return result
}

func Filter(nums []int, fn func(int) bool) []int {
    var result []int
    for _, v := range nums {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}

// 组合使用
numbers := []int{1, 2, 3, 4, 5}
result := Filter(
    Map(numbers, func(x int) int { return x * 2 }),
    func(x int) bool { return x > 5 },
)
fmt.Println(result) // 输出: [6, 8, 10]
</syntaxhighlight>

== 高级模式 ==

=== 管道模式 ===
使用channel实现异步处理链：

<mermaid>
graph LR
    A[数据源] --> B[阶段1处理]
    B --> C[阶段2处理]
    C --> D[结果收集]
</mermaid>

<syntaxhighlight lang="go">
func Generator(done <-chan struct{}, nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            select {
            case out <- n:
            case <-done:
                return
            }
        }
    }()
    return out
}

func Square(done <-chan struct{}, in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {
            select {
            case out <- n * n:
            case <-done:
                return
            }
        }
    }()
    return out
}

// 使用示例
done := make(chan struct{})
defer close(done)

gen := Generator(done, 1, 2, 3, 4)
sq := Square(done, gen)

for n := range sq {
    fmt.Println(n) // 输出: 1 4 9 16
}
</syntaxhighlight>

=== 错误处理 ===
通过自定义类型增强链式调用的健壮性：

<syntaxhighlight lang="go">
type ChainResult struct {
    Value interface{}
    Err   error
}

func (r ChainResult) Then(fn func(interface{}) (interface{}, error)) ChainResult {
    if r.Err != nil {
        return r
    }
    value, err := fn(r.Value)
    return ChainResult{value, err}
}

// 使用示例
result := ChainResult{Value: 10}.
    Then(func(x interface{}) (interface{}, error) { return x.(int) * 2, nil }).
    Then(func(x interface{}) (interface{}, error) { return x.(int) + 5, nil })
fmt.Println(result.Value) // 输出: 25
</syntaxhighlight>

== 实际应用案例 ==

=== 数据清洗管道 ===
处理CSV数据时的典型清洗流程：

<syntaxhighlight lang="go">
type Record map[string]interface{}

func LoadCSV(path string) ([]Record, error) { /* ... */ }

func CleanRecords(records []Record) []Record {
    return FilterRecords(
        NormalizeDates(
            FillMissingValues(
                RemoveDuplicates(records),
            "created_at"),
        func(r Record) bool { return r["valid"].(bool) })
}

// 各处理函数实现链式组合
</syntaxhighlight>

=== HTTP中间件链 ===
Web框架中的中间件典型实现：

<syntaxhighlight lang="go">
type Middleware func(http.Handler) http.Handler

func Chain(middlewares ...Middleware) Middleware {
    return func(final http.Handler) http.Handler {
        for i := len(middlewares) - 1; i >= 0; i-- {
            final = middlewares[i](final)
        }
        return final
    }
}

// 使用示例
handler := Chain(
    LoggingMiddleware,
    AuthMiddleware,
    RateLimitMiddleware,
)(mainHandler)
</syntaxhighlight>

== 性能考量 ==

使用函数链时需注意：
* 每次链式调用都可能产生新内存分配
* 深度嵌套会影响可读性
* 对于性能敏感场景，建议：
  * 预分配切片容量
  * 使用sync.Pool复用对象
  * 考虑并行处理（如fan-out/fan-in模式）

== 最佳实践 ==

1. '''保持函数纯净'''：避免副作用
2. '''限制链长度'''：超过5个操作应考虑拆分
3. '''明确错误处理'''：使用Either模式或Result类型
4. '''类型安全'''：合理使用泛型（Go 1.18+）
5. '''文档注释'''：说明每个链节点的预期行为

通过合理应用函数链技术，可以显著提升Go代码的表达力和模块化程度，特别是在数据处理和流水线操作场景中。

[[Category:编程语言]]
[[Category:Go]]
[[Category:Go 函数式编程]]