编辑“︁Go 高阶函数”︁

= Go高阶函数 =

'''高阶函数'''（Higher-Order Function）是函数式编程中的核心概念之一，在Go语言中同样适用。高阶函数是指可以接收其他函数作为参数，或者将函数作为返回值的函数。这种特性使得代码更加灵活、模块化，并支持更高级的抽象。

== 基本概念 ==

在Go语言中，函数是“一等公民”（First-Class Citizen），这意味着：
* 函数可以作为变量传递
* 函数可以作为其他函数的参数
* 函数可以作为其他函数的返回值

高阶函数利用这些特性，使得代码更具表达力和可复用性。

=== 函数作为参数 ===

以下是一个简单的例子，展示如何将函数作为参数传递：

<syntaxhighlight lang="go">
package main

import "fmt"

// 高阶函数：接收一个函数作为参数
func apply(f func(int) int, x int) int {
    return f(x)
}

// 普通函数
func square(x int) int {
    return x * x
}

func main() {
    result := apply(square, 5)
    fmt.Println(result) // 输出: 25
}
</syntaxhighlight>

在这个例子中：
1. `apply` 是一个高阶函数，它接收一个函数 `f` 和一个整数 `x`。
2. `square` 是一个普通函数，计算平方。
3. 我们将 `square` 函数传递给 `apply`，并得到计算结果。

=== 函数作为返回值 ===

高阶函数也可以返回函数：

<syntaxhighlight lang="go">
package main

import "fmt"

// 高阶函数：返回一个函数
func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    double := multiplier(2)
    triple := multiplier(3)

    fmt.Println(double(5)) // 输出: 10
    fmt.Println(triple(5)) // 输出: 15
}
</syntaxhighlight>

这里：
1. `multiplier` 返回一个匿名函数，该函数会乘以给定的因子。
2. 我们可以创建不同的乘法函数（如 `double` 和 `triple`）并重复使用它们。

== 实际应用案例 ==

高阶函数在Go中有许多实际应用场景，以下是一些常见示例：

=== 1. 自定义排序 ===

Go的 `sort` 包允许通过高阶函数自定义排序逻辑：

<syntaxhighlight lang="go">
package main

import (
    "fmt"
    "sort"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    people := []Person{
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 20},
    }

    // 按年龄排序
    sort.Slice(people, func(i, j int) bool {
        return people[i].Age < people[j].Age
    })

    fmt.Println(people) // 输出: [{Charlie 20} {Alice 25} {Bob 30}]
}
</syntaxhighlight>

=== 2. 中间件模式 ===

在Web开发中，高阶函数常用于中间件：

<syntaxhighlight lang="go">
package main

import (
    "fmt"
    "net/http"
)

// 高阶函数：返回一个处理函数
func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Request received:", r.URL.Path)
        next(w, r)
    }
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", loggingMiddleware(helloHandler))
    http.ListenAndServe(":8080", nil)
}
</syntaxhighlight>

=== 3. 函数组合 ===

高阶函数可以实现函数组合（Function Composition）：

<syntaxhighlight lang="go">
package main

import "fmt"

func compose(f, g func(int) int) func(int) int {
    return func(x int) int {
        return f(g(x))
    }
}

func addOne(x int) int {
    return x + 1
}

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

func main() {
    addThenSquare := compose(square, addOne)
    fmt.Println(addThenSquare(2)) // (2+1)^2 = 9
}
</syntaxhighlight>

== 性能考虑 ==

虽然高阶函数提供了强大的抽象能力，但在性能敏感的场景需要注意：
* 函数调用会有额外的开销
* 闭包可能带来内存分配
* 在热点路径上应谨慎使用

== 总结 ==

高阶函数是Go函数式编程的重要特性，它允许：
* 将函数作为参数传递
* 将函数作为返回值
* 创建更灵活、可复用的代码

通过合理使用高阶函数，可以：
* 减少重复代码
* 提高代码表达力
* 实现更复杂的抽象

<mermaid>
graph TD
    A[高阶函数] --> B[函数作为参数]
    A --> C[函数作为返回值]
    B --> D[自定义排序]
    B --> E[中间件]
    C --> F[工厂模式]
    C --> G[延迟计算]
</mermaid>

高阶函数与普通函数的关系可以用数学表示为：
<math>
\text{HOF}(f, x) = f(x)
</math>
其中：
* <math>\text{HOF}</math> 是高阶函数
* <math>f</math> 是被操作的函数
* <math>x</math> 是输入参数

掌握高阶函数将大大提升你的Go编程能力，特别是在构建可扩展、可维护的系统时。

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