在 Go 语言（Golang）中，函数值（Function Value） 是指函数可以作为一种值进行赋值、传递和调用。这使得 Go 语言具备了 函数式编程 的特点。

1.函数值的基本使用

在 Go 语言中，函数本质上是一种一等公民，可以像其他变量一样赋值给变量、作为参数传递和作为返回值返回。

示例 1：将函数赋值给变量

package main

import "fmt"

func add(a, b int) int {
    return a + b
}

func main() {
    // 将函数赋值给变量
    sum := add

    // 通过变量调用函数
    result := sum(3, 5)

    fmt.Println("结果:", result) // 输出: 结果: 8
}

在这个示例中，sum 变量存储了 add 函数，并可以像调用 add 函数一样使用 sum 进行调用。

2.函数值作为参数

Go 允许将一个函数作为参数传递给另一个函数，这使得代码更灵活，可用于回调（Callback）等场景。

示例 2：函数作为参数

package main

import "fmt"

// 定义一个函数，参数是一个函数 f
func operate(a, b int, f func(int, int) int) int {
    return f(a, b)
}

// 定义两个具体的函数
func add(a, b int) int {
    return a + b
}

func multiply(a, b int) int {
    return a * b
}

func main() {
    // 传递不同的函数作为参数
    fmt.Println("加法结果:", operate(4, 2, add))       // 输出: 加法结果: 6
    fmt.Println("乘法结果:", operate(4, 2, multiply))  // 输出: 乘法结果: 8
}

在这个示例中，operate 函数接受一个函数类型的参数 f，这样我们可以在 main 函数中传递不同的运算函数（add 或 multiply），实现不同的计算逻辑。

3.函数值作为返回值

函数还可以作为返回值返回，使得代码可以动态返回不同的函数，从而更灵活地控制逻辑。

示例 3：返回函数

package main

import "fmt"

// 返回一个计算函数
func getOperator(op string) func(int, int) int {
    if op == "add" {
        return func(a, b int) int { return a + b }
    } else if op == "multiply" {
        return func(a, b int) int { return a * b }
    } else {
        return func(a, b int) int { return 0 }
    }
}

func main() {
    addFunc := getOperator("add")       // 获取加法函数
    multiplyFunc := getOperator("multiply") // 获取乘法函数

    fmt.Println("加法:", addFunc(3, 5))   // 输出: 加法: 8
    fmt.Println("乘法:", multiplyFunc(3, 5)) // 输出: 乘法: 15
}

这里的 getOperator 根据不同的 op 参数返回不同的函数，实现了类似工厂模式的效果。

4.匿名函数

Go 语言支持 匿名函数，即 没有名字的函数，可以用作函数值。

示例 4：匿名函数

package main

import "fmt"

func main() {
    // 直接定义匿名函数，并赋值给变量
    square := func(x int) int {
        return x * x
    }

    fmt.Println("平方:", square(4)) // 输出: 平方: 16
}

匿名函数通常用于临时使用，特别是在函数参数传递时，可以省去定义一个单独的函数。

5.闭包（Closure）

Go 语言的闭包指的是一个捕获了外部变量的函数，这样即使外部变量离开作用域，函数仍然可以访问它。

示例 5：闭包

package main

import "fmt"

// 生成一个累加器
func accumulator() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x // 访问并修改外部变量 sum
        return sum
    }
}

func main() {
    acc := accumulator()

    fmt.Println(acc(1)) // 输出: 1
    fmt.Println(acc(2)) // 输出: 3
    fmt.Println(acc(3)) // 输出: 6
}

这里 accumulator 函数返回了一个匿名函数，这个匿名函数捕获了 sum 变量，并且在每次调用时都能保留 sum 的值。

6.总结

• 函数可以作为值赋值给变量，并可以像普通变量一样传递和调用。
• 函数可以作为参数 传递给其他函数，实现更灵活的计算。
• 函数可以作为返回值，可以动态生成不同的函数。
• 匿名函数 是没有名字的函数，适用于临时使用。
• 闭包 允许函数捕获外部变量，使得函数可以记住其执行环境。

这些特性让 Go 语言在编写高阶函数、回调函数、动态函数等场景时更加灵活和高效！