返回专栏
· 15 分钟阅读

高阶函数与函数组合


一、高阶函数(Higher-Order Function)

1. 什么是高阶函数

高阶函数是指满足以下任意一个条件的函数:

  1. 接收一个或多个函数作为参数。
  2. 将函数作为返回值返回。

这意味着函数不仅可以执行逻辑,还可以像普通数据一样被传递、保存和动态创建。

例如:

function applyOperation(value, operation) {
    return operation(value);
}

function double(x) {
    return x * 2;
}

console.log(applyOperation(5, double)); // 10

这里,applyOperation 接收 operation 函数作为参数,因此它是一个高阶函数。

另一个例子:

function createMultiplier(factor) {
    return function (value) {
        return value * factor;
    };
}

const double = createMultiplier(2);
const triple = createMultiplier(3);

console.log(double(5)); // 10
console.log(triple(5)); // 15

createMultiplier 返回一个函数,同样属于高阶函数。

2. 函数是一等公民

高阶函数建立在函数是一等公民(First-Class Function)的基础上。

一等公民意味着函数可以像普通值一样参与语言中的操作:

  • 赋值给变量。
  • 作为参数传递。
  • 作为函数返回值。
  • 存储在数组、对象或其他数据结构中。
  • 在运行时动态创建和调用。

例如:

const add = (a, b) => a + b;

const operation = add;

const operations = [
    (x) => x + 1,
    (x) => x * 2,
    (x) => x * x
];

console.log(operation(2, 3)); // 5
console.log(operations[1](5)); // 10

需要区分两个概念:

概念 含义
一等函数(First-Class Function) 函数可以像普通值一样被操作
高阶函数(Higher-Order Function) 函数接收函数或返回函数

一等函数是语言提供的能力,高阶函数是基于这种能力构建的抽象方式。

3. 常见高阶函数

高阶函数广泛存在于标准库、集合操作、异步编程和事件系统中。

3.1 map:映射转换

map 对集合中的每个元素执行转换函数,返回一个新集合。

const numbers = [1, 2, 3, 4];

const result = numbers.map(x => x * 2);

console.log(result); // [2, 4, 6, 8]

核心语义:

  • 输入:一个集合和一个转换函数。
  • 操作:将函数应用于每个元素。
  • 输出:由转换结果组成的新集合。

数学上可以表示为:

map(f,[x_1,x_2,\ldots,x_n]) = [f(x_1),f(x_2),\ldots,f(x_n)]

3.2 filter:条件筛选

filter 根据判断函数筛选集合元素。

const numbers = [1, 2, 3, 4, 5, 6];

const result = numbers.filter(x => x % 2 === 0);

console.log(result); // [2, 4, 6]

判断函数返回真值的元素会被保留。

3.3 reduce:归约计算

reduce 将集合中的多个元素逐步归约为一个结果。

const numbers = [1, 2, 3, 4];

const sum = numbers.reduce(
    (accumulator, current) => accumulator + current,
    0
);

console.log(sum); // 10

其基本形式:

reduce(f,initial,[x_1,\ldots,x_n])

每次调用归约函数时,都会传入当前累积值和下一个元素。

3.4 forEach:遍历执行

forEach 将函数应用于集合中的每个元素,通常用于执行副作用。

const users = ["Alice", "Bob", "Carol"];

users.forEach(user => {
    console.log(`Hello, ${user}`);
});

它与 map 的重要区别是:forEach 不用于生成转换后的新集合,返回值通常为 undefined。

3.5 函数工厂:返回函数

函数工厂通过参数决定生成函数的行为。

function createValidator(min, max) {
    return function (value) {
        return value >= min && value <= max;
    };
}

const validateAge = createValidator(18, 60);

console.log(validateAge(25)); // true
console.log(validateAge(15)); // false

返回的函数保留了对 min 和 max 的访问能力,这涉及闭包(Closure)机制。

4. 高阶函数的执行机制

高阶函数本身并没有特殊的底层执行指令。它依赖语言的函数对象、调用机制和作用域规则。

以函数作为参数为例:

function execute(value, callback) {
    const result = callback(value);
    return result;
}

function square(x) {
    return x * x;
}

const result = execute(5, square);

执行过程:

flowchart TD
    A["调用 execute(5, square)"] --> B["传入 value 和 callback"]
    B --> C["callback 指向 square"]
    C --> D["调用 callback(value)"]
    D --> E["执行 square(5)"]
    E --> F["返回 25"]
    F --> G["execute 返回结果"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这里需要注意:

  • 传递函数时,传递的是函数引用,而不是函数执行结果。
  • 只有发生函数调用时,函数体才会执行。
  • 回调函数在哪个时机执行,由调用方的实现决定。
  • 回调函数可以同步执行,也可以在异步任务完成后执行。

5. 高阶函数与闭包

高阶函数经常与闭包结合使用,但两者不是同一个概念。

闭包是函数及其所捕获的词法环境的组合。函数即使离开原来的外层函数作用域,仍然可以访问捕获的变量。

function createCounter() {
    let count = 0;

    return function () {
        count++;
        return count;
    };
}

const counter = createCounter();

console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

这里:

  • createCounter 是高阶函数,因为它返回函数。
  • 返回的匿名函数是闭包,因为它访问外层作用域中的 count。
  • count 的状态在多次调用之间得到保留。

高阶函数不一定产生闭包,闭包也不一定由高阶函数返回。


二、函数组合(Function Composition)

1. 什么是函数组合

函数组合是将多个函数连接起来,使一个函数的输出成为另一个函数的输入,从而构建新的函数。

假设有两个函数:

f:A\rightarrow B
g:B\rightarrow C

那么可以组合为:

g\circ f:A\rightarrow C

其含义是先执行 f,再执行 g:

(g\circ f)(x)=g(f(x))

例如:

const addOne = x => x + 1;
const double = x => x * 2;

const result = double(addOne(5));

console.log(result); // 12

执行顺序:

flowchart LR
    A["输入 5"] --> B["addOne"]
    B --> C["得到 6"]
    C --> D["double"]
    D --> E["得到 12"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

函数组合的核心是将复杂逻辑拆分为多个职责单一的小函数,再通过组合构建完整行为。

2. compose:从右向左组合

compose 是函数组合的一种常见实现方式。

多个函数按照从右向左的顺序执行:

compose(f,g,h)(x)=f(g(h(x)))

实现:

const compose = (...fns) =>
    value => fns.reduceRight(
        (result, fn) => fn(result),
        value
    );

const addOne = x => x + 1;
const double = x => x * 2;
const square = x => x * x;

const calculate = compose(square, double, addOne);

console.log(calculate(3)); // 64

执行过程:

  1. addOne(3) 得到 4。
  2. double(4) 得到 8。
  3. square(8) 得到 64。

注意:compose 的参数排列顺序与实际执行顺序相反。

3. pipe:从左向右组合

pipe 与 compose 的核心思想相同,区别在于函数执行方向。

pipe(f,g,h)(x)=h(g(f(x)))

实现:

const pipe = (...fns) =>
    value => fns.reduce(
        (result, fn) => fn(result),
        value
    );

const addOne = x => x + 1;
const double = x => x * 2;
const square = x => x * x;

const calculate = pipe(addOne, double, square);

console.log(calculate(3)); // 64

pipe 更接近自然语言中的处理顺序,通常更容易阅读复杂的数据处理流程。

4. compose 与 pipe 的区别

对比维度 compose pipe
执行方向 从右向左 从左向右
参数顺序 最先执行的函数放在最后 最先执行的函数放在最前
数学表达 f(g(h(x))) h(g(f(x)))
实现方式 reduceRight reduce
阅读习惯 数学函数组合风格 流水线处理风格

两者都要求相邻函数的输入输出类型能够衔接。

5. 函数组合的数学性质

函数组合不仅是一种代码组织方式,还具有明确的数学性质。

5.1 结合律(Associativity)

函数组合满足结合律:

(f\circ g)\circ h=f\circ(g\circ h)

只要函数类型能够正确衔接,改变组合的分组方式不会改变结果。

这意味着:

const left = compose(f, compose(g, h));
const right = compose(compose(f, g), h);

在函数语义一致的前提下,两者等价。

但需要注意,结合律不代表可以任意改变函数执行顺序。

5.2 不满足交换律(Non-commutativity)

通常:

f\circ g\neq g\circ f

例如:

const addOne = x => x + 1;
const double = x => x * 2;

console.log(double(addOne(3))); // 8
console.log(addOne(double(3))); // 7

函数组合不能随意交换位置,因为执行顺序会影响最终结果。

5.3 恒等函数(Identity Function)

恒等函数满足:

id(x)=x

它与其他函数组合时,不会改变函数行为:

f\circ id=f
id\circ f=f

JavaScript 实现:

const identity = x => x;

const compose = (f, g) => x => f(g(x));

const addOne = x => x + 1;

const result = compose(addOne, identity)(5);

console.log(result); // 6

恒等函数在泛型处理、函数组合抽象和函数式库设计中具有重要作用。


三、高阶函数与函数组合的关系

高阶函数提供函数作为参数和返回值的能力,函数组合则利用这种能力,将多个函数组织为一个新的函数。

两者关系:

维度 高阶函数 函数组合
核心概念 函数接收函数或返回函数 多个函数连接形成新函数
主要目的 提升抽象与复用能力 组织复杂逻辑
典型操作 map、filter、reduce、回调 compose、pipe
依赖关系 依赖一等函数 通常通过高阶函数实现
应用场景 回调、策略、事件、函数工厂 数据转换、业务流程、管道处理

并非所有高阶函数都是函数组合,也并非所有函数组合都必须通过通用的 compose 实现。

例如,filter 是高阶函数,但它本身并不必然表示多个函数的组合。


四、函数组合的实际应用

1. 数据处理管道

在实际业务中,经常需要对原始数据进行清洗、转换和筛选。

const normalize = users =>
    users.map(user => ({
        ...user,
        name: user.name.trim().toLowerCase()
    }));

const filterActive = users =>
    users.filter(user => user.active);

const extractNames = users =>
    users.map(user => user.name);

const pipe = (...fns) =>
    value => fns.reduce(
        (result, fn) => fn(result),
        value
    );

const processUsers = pipe(
    normalize,
    filterActive,
    extractNames
);

const users = [
    { name: " Alice ", active: true },
    { name: " Bob ", active: false },
    { name: " Carol ", active: true }
];

console.log(processUsers(users));
// ["alice", "carol"]

业务逻辑被拆分为三个独立函数:

  • normalize:规范化数据。
  • filterActive:筛选有效用户。
  • extractNames:提取用户名称。

每个函数可以单独测试,也可以在其他业务流程中复用。

2. 函数式中间件

中间件(Middleware)通常通过高阶函数包装原有函数,在不修改原始业务逻辑的情况下增加额外行为。

function withLogging(fn) {
    return function (...args) {
        console.log("开始执行");

        const result = fn(...args);

        console.log("执行完成");

        return result;
    };
}

function calculate(a, b) {
    return a + b;
}

const loggedCalculate = withLogging(calculate);

console.log(loggedCalculate(2, 3));

withLogging 接收一个函数,并返回一个包装后的函数。

这是一种典型的装饰器式高阶函数应用。

需要注意,这个示例只适用于同步函数。如果 fn 返回 Promise,当前实现会在 Promise 完成前输出“执行完成”。对于异步函数,需要包装 Promise 的完成与失败过程。

3. 函数式错误处理

可以通过高阶函数将异常处理逻辑与业务逻辑分离。

function withErrorHandling(fn) {
    return function (...args) {
        try {
            return {
                success: true,
                data: fn(...args)
            };
        } catch (error) {
            return {
                success: false,
                error: error.message
            };
        }
    };
}

function divide(a, b) {
    if (b === 0) {
        throw new Error("除数不能为零");
    }

    return a / b;
}

const safeDivide = withErrorHandling(divide);

console.log(safeDivide(10, 2));
// { success: true, data: 5 }

console.log(safeDivide(10, 0));
// { success: false, error: "除数不能为零" }

这种方式可以将错误处理策略复用于多个函数。

不过,异常捕获边界需要合理设计,不能为了统一返回格式而吞掉系统级错误或不可恢复错误。

4. 函数组合与异步处理

同步函数组合要求每个函数的输出能够作为下一个函数的输入。