Go函数作为值与高阶函数

Go函数是一等公民，可赋值、传递、作为返回值。

函数类型

定义函数类型

// 函数类型定义
type AddFunc func(a, b int) int

// 使用函数类型
var add AddFunc = func(a, b int) int {
    return a + b
}

result := add(1, 2)

函数类型签名

// 函数类型签名格式
func(参数类型) 返回值类型

// 示例
type Handler func(int) int
type Processor func(string) (string, error)
type Callback func()

函数作为值

函数赋值给变量

// 函数赋值
var f func(int) int

f = func(n int) int {
    return n * 2
}

fmt.Println(f(5))  // 10

函数变量调用

// 函数变量可多次赋值
var operation func(int, int) int

operation = func(a, b int) int { return a + b }
fmt.Println(operation(1, 2))  // 3

operation = func(a, b int) int { return a - b }
fmt.Println(operation(1, 2))  // -1

函数作为参数（回调）

基本回调模式

// 函数作为参数
func process(data []int, fn func(int) int) []int {
    result := make([]int, len(data))
    for i, v := range data {
        result[i] = fn(v)
    }
    return result
}

// 传递不同函数
nums := []int{1, 2, 3}

double := process(nums, func(n int) int { return n * 2 })
fmt.Println(double)  // [2, 4, 6]

square := process(nums, func(n int) int { return n * n })
fmt.Println(square)  // [1, 4, 9]

使用函数类型简化

type MapFunc func(int) int

func mapInts(data []int, fn MapFunc) []int {
    result := make([]int, len(data))
    for i, v := range data {
        result[i] = fn(v)
    }
    return result
}

函数作为返回值

返回函数

// 返回函数
func getMultiplier(factor int) func(int) int {
    return func(n int) int {
        return n * factor
    }
}

// 使用
double := getMultiplier(2)
triple := getMultiplier(3)

fmt.Println(double(5))  // 10
fmt.Println(triple(5))  // 15

闭包工厂

// 闭包工厂：返回配置化的函数
func makeAdder(base int) func(int) int {
    return func(n int) int {
        return base + n
    }
}

add10 := makeAdder(10)
add20 := makeAdder(20)

fmt.Println(add10(5))  // 15
fmt.Println(add20(5))  // 25

高阶函数模式

Filter过滤

type Predicate func(int) bool

func filter(nums []int, p Predicate) []int {
    result := []int{}
    for _, v := range nums {
        if p(v) {
            result = append(result, v)
        }
    }
    return result
}

// 使用
nums := []int{1, 2, 3, 4, 5, 6}

evens := filter(nums, func(n int) bool {
    return n % 2 == 0
})
fmt.Println(evens)  // [2, 4, 6]

Reduce聚合

type Reducer func(acc, val int) int

func reduce(nums []int, initial int, fn Reducer) int {
    acc := initial
    for _, v := range nums {
        acc = fn(acc, v)
    }
    return acc
}

// 求和
sum := reduce(nums, 0, func(a, b int) int { return a + b })
fmt.Println(sum)  // 21

组合函数

// 函数组合
func compose(f, g func(int) int) func(int) int {
    return func(n int) int {
        return f(g(n))
    }
}

double := func(n int) int { return n * 2 }
addOne := func(n int) int { return n + 1 }

doubleThenAdd := compose(addOne, double)
fmt.Println(doubleThenAdd(5))  // 11 (5*2+1)

addThenDouble := compose(double, addOne)
fmt.Println(addThenDouble(5))  // 12 ((5+1)*2)

高阶函数应用表

函数是一等公民

要点总结

• 函数是一等公民，可赋值、传递、返回
• 函数类型定义签名格式
• 函数作为参数实现回调模式
• 函数作为返回值实现闭包工厂
• 高阶函数：Map、Filter、Reduce
• 函数组合：compose连接多个函数
• 函数可存入slice、map等数据结构