一、高阶函数(Higher-Order Function)
1. 什么是高阶函数
高阶函数是指满足以下任意一个条件的函数:
- 接收一个或多个函数作为参数。
- 将函数作为返回值返回。
这意味着函数不仅可以执行逻辑,还可以像普通数据一样被传递、保存和动态创建。
例如:
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]
核心语义:
- 输入:一个集合和一个转换函数。
- 操作:将函数应用于每个元素。
- 输出:由转换结果组成的新集合。
数学上可以表示为:
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
其基本形式:
每次调用归约函数时,都会传入当前累积值和下一个元素。
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,再执行 g:
例如:
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 是函数组合的一种常见实现方式。
多个函数按照从右向左的顺序执行:
实现:
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
执行过程:
addOne(3)得到 4。double(4)得到 8。square(8)得到 64。
注意:compose 的参数排列顺序与实际执行顺序相反。
3. pipe:从左向右组合
pipe 与 compose 的核心思想相同,区别在于函数执行方向。
实现:
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)
函数组合满足结合律:
只要函数类型能够正确衔接,改变组合的分组方式不会改变结果。
这意味着:
const left = compose(f, compose(g, h));
const right = compose(compose(f, g), h);
在函数语义一致的前提下,两者等价。
但需要注意,结合律不代表可以任意改变函数执行顺序。
5.2 不满足交换律(Non-commutativity)
通常:
例如:
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)
恒等函数满足:
它与其他函数组合时,不会改变函数行为:
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. 函数组合与异步处理
同步函数组合要求每个函数的输出能够作为下一个函数的输入。