编辑“︁Go 函数组合”︁

= Go函数组合 =

'''函数组合'''（Function Composition）是函数式编程中的核心概念之一，它允许开发者将多个函数串联起来，形成一个新的函数，使得数据可以像流水线一样依次通过各个函数进行处理。在Go语言中，虽然它不是纯函数式语言，但仍然可以通过高阶函数和闭包来实现函数组合。

== 基本概念 ==

函数组合的数学定义可以表示为：给定两个函数<math>f: X \rightarrow Y</math>和<math>g: Y \rightarrow Z</math>，它们的组合<math>g \circ f</math>是一个新函数，定义为<math>(g \circ f)(x) = g(f(x))</math>。在Go中，我们可以通过将函数作为参数传递或返回函数来实现类似的效果。

=== 为什么使用函数组合？ ===
* '''代码复用'''：避免重复编写相似的逻辑。
* '''模块化'''：将复杂逻辑拆解为多个小函数，便于维护。
* '''可读性'''：链式调用让代码更清晰表达数据处理流程。

== Go中的函数组合实现 ==

=== 基本示例 ===
以下是一个简单的函数组合示例，将两个函数`addOne`和`square`组合成一个新函数：

<syntaxhighlight lang="go">
package main

import "fmt"

// 定义两个基本函数
func addOne(x int) int {
    return x + 1
}

func square(x int) int {
    return x * x
}

// 组合函数：先执行addOne，再执行square
func compose(f func(int) int, g func(int) int) func(int) int {
    return func(x int) int {
        return g(f(x))
    }
}

func main() {
    // 组合成新函数
    addThenSquare := compose(addOne, square)

    result := addThenSquare(2) // (2 + 1)^2 = 9
    fmt.Println(result)        // 输出: 9
}
</syntaxhighlight>

=== 可变参数组合 ===
如果需要组合多个函数，可以使用可变参数：

<syntaxhighlight lang="go">
func composeMany(funcs ...func(int) int) func(int) int {
    return func(x int) int {
        for _, f := range funcs {
            x = f(x)
        }
        return x
    }
}

func main() {
    triple := func(x int) int { return x * 3 }
    pipeline := composeMany(addOne, square, triple)

    result := pipeline(2) // ((2 + 1)^2) * 3 = 27
    fmt.Println(result)   // 输出: 27
}
</syntaxhighlight>

== 实际应用案例 ==

=== 数据处理管道 ===
在数据处理场景中，函数组合可以构建清晰的数据转换流程：

<syntaxhighlight lang="go">
func filterEven(nums []int) []int {
    var result []int
    for _, n := range nums {
        if n%2 == 0 {
            result = append(result, n)
        }
    }
    return result
}

func double(nums []int) []int {
    for i := range nums {
        nums[i] *= 2
    }
    return nums
}

func processData(pipeline ...func([]int) []int) func([]int) []int {
    return func(data []int) []int {
        for _, f := range pipeline {
            data = f(data)
        }
        return data
    }
}

func main() {
    data := []int{1, 2, 3, 4, 5}
    processor := processData(filterEven, double)
    fmt.Println(processor(data)) // 输出: [4 8]
}
</syntaxhighlight>

=== HTTP中间件 ===
函数组合在Web开发中常用于中间件设计：

<syntaxhighlight lang="go">
type HandlerFunc func(http.ResponseWriter, *http.Request)

func logMiddleware(next HandlerFunc) HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Request received:", r.URL.Path)
        next(w, r)
    }
}

func authMiddleware(next HandlerFunc) HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("Authorization") == "" {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
        next(w, r)
    }
}

func finalHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, authenticated user!"))
}

func main() {
    handler := logMiddleware(authMiddleware(finalHandler))
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}
</syntaxhighlight>

== 高级技巧 ==

=== 泛型组合（Go 1.18+） ===
使用泛型可以创建更通用的组合函数：

<syntaxhighlight lang="go">
func Compose[T any](funcs ...func(T) T) func(T) T {
    return func(x T) T {
        for _, f := range funcs {
            x = f(x)
        }
        return x
    }
}

func main() {
    toUpper := func(s string) string { return strings.ToUpper(s) }
    addExclaim := func(s string) string { return s + "!" }

    transform := Compose(toUpper, addExclaim)
    fmt.Println(transform("hello")) // 输出: HELLO!
}
</syntaxhighlight>

=== 错误处理组合 ===
处理可能返回错误的函数组合：

<syntaxhighlight lang="go">
func composeWithErr(f func(int) (int, error), g func(int) (int, error)) func(int) (int, error) {
    return func(x int) (int, error) {
        y, err := f(x)
        if err != nil {
            return 0, err
        }
        return g(y)
    }
}
</syntaxhighlight>

== 可视化流程 ==

<mermaid>
graph LR
    A[输入] --> B[函数f]
    B --> C[中间结果]
    C --> D[函数g]
    D --> E[输出]
</mermaid>

== 注意事项 ==
* '''执行顺序'''：组合函数时要注意函数的执行顺序，<code>compose(f, g)</code>表示先执行<code>f</code>后执行<code>g</code>
* '''性能考量'''：过多的函数组合可能影响性能，特别是在循环中调用时
* '''调试难度'''：组合后的调用栈较深，可能增加调试难度

== 总结 ==
Go函数组合提供了一种强大的抽象工具，虽然Go不是函数式语言，但通过高阶函数和闭包仍然可以实现优雅的函数组合。从简单的数据处理到复杂的中间件设计，函数组合都能显著提升代码的模块化和可维护性。掌握这一概念将帮助你编写更简洁、更富有表达力的Go代码。

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