返回专栏
· 17 分钟阅读

高阶函数(Higher-order Function)


一、什么是高阶函数

高阶函数(Higher-order Function,简称 HOF)是指满足以下至少一个条件的函数:

  1. 接收函数作为参数:将其他函数传入当前函数,由当前函数决定何时、如何调用。
  2. 返回函数作为结果:函数执行后返回另一个函数,使行为能够被延迟执行、组合或动态生成。

只要满足其中一个条件,就属于高阶函数。

1.1 普通函数与高阶函数

普通函数通常接收数据并返回数据:

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

const result = add(10, 20);

高阶函数可以接收另一个函数:

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

const result = calculate(10, 20, add);

也可以返回一个函数:

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

const double = createMultiplier(2);

console.log(double(10)); // 20

1.2 高阶函数的判断标准

判断条件 是否属于高阶函数 示例
接收普通数值参数 否 add(1, 2)
接收函数参数 是 map(array, callback)
返回普通数值 否 getValue()
返回函数 是 createHandler()
同时接收函数并返回函数 是 装饰器、高阶包装函数

需要注意:

  • 函数作为参数传递,本身并不意味着调用方一定会立即执行它。
  • 返回函数不等于立即执行返回的函数。
  • 高阶函数描述的是函数与其他函数之间的关系,而不是某一种特定语法。

二、高阶函数的底层基础

高阶函数能够成立,依赖于编程语言对函数的一种重要支持:函数可以像普通数据一样被操作和传递。

这通常与一等函数(First-class Function)密切相关。

2.1 一等函数(First-class Function)

一等函数是指函数在语言中拥有与其他普通值相近的使用能力,通常包括:

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

例如:

function greet(name) {
    return `Hello, ${name}`;
}

// 赋值给变量
const fn = greet;

// 作为参数传递
function execute(callback) {
    return callback("Reverie");
}

console.log(execute(fn));

// 存储在数组中
const handlers = [greet, fn];

// 从数组中取出并调用
console.log(handlers[0]("Developer"));

这里的 greet、fn 和 handlers[0] 都指向可以调用的函数值。

2.2 一等函数与高阶函数的区别

两者不是同一个概念。

概念 核心含义 关注点
一等函数 函数可以作为普通值使用 语言能力
高阶函数 函数接收或返回其他函数 函数行为
匿名函数 没有显式名称的函数 函数定义形式
Lambda 表达式 使用特定语法定义函数 语法表达能力
闭包 函数与其捕获的词法环境组合 变量访问与生命周期

一等函数为高阶函数提供了基础,但两者不能混为一谈。

例如,一门语言支持将函数赋值给变量,并不代表它的所有函数都必须采用高阶函数的方式编写。

2.3 函数作为值的执行过程

当函数作为参数传递时,通常传递的是函数值或函数引用,而不是函数执行后的结果。

function sayHello() {
    console.log("Hello");
}

function execute(callback) {
    callback();
}

// 传递函数本身
execute(sayHello);

// 传递函数执行结果
execute(sayHello());

这两种写法有本质区别:

  • execute(sayHello):将函数传递给 execute,由其内部调用。
  • execute(sayHello()):先执行 sayHello(),再把执行结果传入 execute。

如果 sayHello() 没有返回函数,第二种写法通常会导致参数不是一个可调用函数。

三、高阶函数的两种基本形式

高阶函数主要有两种形式:接收函数参数,以及返回函数。

3.1 接收函数作为参数

这是最常见的高阶函数形式。

function processData(data, callback) {
    const result = data * 2;
    return callback(result);
}

function format(value) {
    return `结果:${value}`;
}

const result = processData(10, format);

console.log(result); // 结果:20

执行过程:

flowchart TD
    A["调用 processData"] --> B["传入数据 data"]
    B --> C["传入函数 callback"]
    C --> D["计算中间结果"]
    D --> E["调用 callback"]
    E --> F["返回最终结果"]

    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

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

高阶函数负责控制整体流程,传入的函数负责提供具体行为。

这种设计将:

  • 流程控制与业务逻辑分离。
  • 通用处理逻辑与具体操作分离。
  • 固定算法结构与可变行为分离。

3.2 返回一个函数

高阶函数也可以在执行后返回另一个函数。

function createAdder(base) {
    return function (value) {
        return base + value;
    };
}

const add10 = createAdder(10);
const add20 = createAdder(20);

console.log(add10(5)); // 15
console.log(add20(5)); // 25

createAdder 返回的函数能够继续访问外层函数中的 base 变量。

即使 createAdder 已经执行结束,返回的函数仍然可以访问它捕获的变量。

这是高阶函数与闭包结合的典型场景。

执行过程:

flowchart TD
    A["调用 createAdder(10)"] --> B["创建外层执行环境"]
    B --> C["生成内部函数"]
    C --> D["内部函数捕获 base"]
    D --> E["返回内部函数"]
    E --> F["外层函数执行结束"]
    F --> G["调用返回的函数"]
    G --> H["读取捕获的 base"]
    H --> I["计算并返回结果"]

    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:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style I fill:#FFF5DE,stroke:#E8D29A,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

3.3 两种形式的组合

高阶函数可以同时接收函数参数并返回函数。

function compose(f, g) {
    return function (value) {
        return f(g(value));
    };
}

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

function increment(value) {
    return value + 1;
}

const composed = compose(double, increment);

console.log(composed(5)); // 12

其执行逻辑:

composed(5)
    → increment(5)
    → 6
    → double(6)
    → 12

compose 将两个函数组合为一个新函数,形成可复用的行为单元。

四、常见高阶函数

高阶函数在现代编程语言中非常普遍,尤其常见于集合处理、异步编程、事件处理和函数式编程。

4.1 map:映射转换

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

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

const result = numbers.map(function (item) {
    return item * 2;
});

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

处理逻辑:

flowchart TD
    A["输入数组"] --> B["读取当前元素"]
    B --> C["调用映射函数"]
    C --> D["生成转换结果"]
    D --> E{"是否还有元素"}
    E -->|"是"| B
    E -->|"否"| F["返回新数组"]

    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:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

适用场景:

  • 数据格式转换。
  • 对象属性提取。
  • 数据结构映射。
  • 统一格式化处理。

4.2 filter:条件过滤

filter 根据传入的判断函数筛选元素,返回满足条件的新集合。

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

const result = numbers.filter(function (item) {
    return item % 2 === 0;
});

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

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

适用场景:

  • 查询符合条件的数据。
  • 过滤无效记录。
  • 权限与状态筛选。
  • 数据清洗。

4.3 reduce:归约计算

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

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

const total = numbers.reduce(function (acc, current) {
    return acc + current;
}, 0);

console.log(total); // 10

其中:

  • acc:累积器,保存上一次计算结果。
  • current:当前处理的元素。
  • 0:初始累积值。

归约过程:

flowchart TD
    A["初始值 acc = 0"] --> B["读取元素 1"]
    B --> C["acc = 0 + 1"]
    C --> D["acc = 1"]
    D --> E["读取元素 2"]
    E --> F["acc = 1 + 2"]
    F --> G["acc = 3"]
    G --> H["继续处理剩余元素"]
    H --> I["最终 acc = 10"]

    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:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

reduce 不局限于求和,还可以实现:

  • 分组统计。
  • 对象构建。
  • 数据聚合。
  • 多层结构扁平化。
  • 状态累积。

4.4 sort:自定义排序

sort 可以接收比较函数,用于定义元素之间的排序规则。

const numbers = [10, 3, 25, 7];

numbers.sort(function (a, b) {
    return a - b;
});

console.log(numbers); // [3, 7, 10, 25]

在 JavaScript 中:

  • 比较函数返回负数:a 排在 b 前面。
  • 返回正数:b 排在 a 前面。
  • 返回零:两者在排序规则中视为相等。

注意,JavaScript 的 sort 会原地修改原数组。若需要保留原数组,可以先复制再排序:

const sorted = [...numbers].sort((a, b) => a - b);

4.5 forEach:遍历执行

forEach 接收回调函数,对集合中的每个元素执行指定操作。

const names = ["Alice", "Bob", "Tom"];

names.forEach(function (name) {
    console.log(name);
});

它与 map 的主要区别:

对比项 map forEach
是否接收回调 是 是
是否返回新数组 是 否,返回 undefined
主要用途 数据转换 遍历执行副作用
是否适合链式数据处理 是 通常不适合

五、高阶函数与回调函数

高阶函数和回调函数经常一起出现,但两者代表不同的角色。

5.1 什么是回调函数

回调函数(Callback Function)是作为参数传递给另一个函数,并由接收方在适当时机调用的函数。

function fetchData(callback) {
    const data = {
        id: 1,
        name: "Reverie"
    };

    callback(data);
}

function handleData(data) {
    console.log(data.name);
}

fetchData(handleData);

在这个例子中:

  • fetchData 是高阶函数。
  • handleData 是回调函数。
  • callback 是接收回调函数的参数。

5.2 两者的关系

概念 角色 说明
高阶函数 接收方或返回方 接收函数或返回函数
回调函数 被传递的函数 由接收方在适当时机调用
函数参数 传递载体 用于接收函数值

回调函数不一定是异步函数。

例如:

[1, 2, 3].map(item => item * 2);

map 中的回调函数是同步执行的。

而下面的回调函数由定时器在后续事件循环中执行:

setTimeout(() => {
    console.log("执行完成");
}, 1000);

因此,回调描述的是函数的传递和调用关系,异步描述的是执行时序,两者不能混为一谈。

六、高阶函数与闭包的关系

高阶函数和闭包经常协同使用,但它们解决的问题不同。

  • 高阶函数:控制函数的传递、组合和返回。
  • 闭包:使函数能够访问其定义时所在的词法环境。

例如:

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

这里同时涉及两个概念:

  1. createCounter 返回一个函数,因此它是高阶函数。
  2. 返回的函数能够继续访问 count,因此它形成了闭包。

闭包使函数可以持有独立的状态。

多个调用可以拥有不同的状态:

const counterA = createCounter();
const counterB = createCounter();

console.log(counterA()); // 1
console.log(counterA()); // 2

console.log(counterB()); // 1

counterA 和 counterB 各自拥有独立的词法环境。

七、高阶函数与函数组合

函数组合(Function Composition)是函数式编程中的重要思想。

其核心是将多个简单函数连接起来,形成一个新的复合函数。

7.1 函数组合的数学表达

假设有两个函数:

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

那么可以将它们组合为:

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

组合后得到:

f \circ g: A \rightarrow C

注意,函数组合的执行顺序是从右向左:先执行 g,再执行 f。

7.2 实现 compose

function compose(...functions) {
    return function (value) {
        return functions.reduceRight(
            (result, fn) => fn(result),
            value
        );
    };
}

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

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

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

执行顺序:

pipeline(3)
    → addOne(3)
    → 4
    → double(4)
    → 8
    → square(8)
    → 64

这里的 compose 本身是高阶函数:

  • 接收多个函数作为参数。
  • 返回一个新的复合函数。

7.3 compose 与 pipe

两者的核心区别是执行方向。

函数 执行方向 示例
compose 从右向左 f(g(h(x)))
pipe 从左向右 h(g(f(x)))

pipe 的一种实现方式:

function pipe(...functions) {
    return function (value) {
        return functions.reduce(
            (result, fn) => fn(result),
            value
        );
    };
}

函数组合可以将复杂业务拆解为多个小函数,使每个函数职责单一、易于测试和复用。

需要注意,组合函数通常要求前一个函数的输出类型能够作为下一个函数的输入类型。异步函数、异常处理和多参数函数需要额外设计组合规则。

八、高阶函数的典型应用场景

8.1 装饰器模式

高阶函数可以包装已有函数,在不直接修改原函数实现的情况下增加额外行为。

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

        const result = fn(...args);

        console.log("函数执行结束");

        return result;
    };
}

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

const loggedAdd = withLogging(add);

console.log(loggedAdd(10, 20));

withLogging 接收一个函数并返回一个新函数。

典型应用:

  • 日志记录。
  • 性能监控。
  • 权限校验。
  • 缓存。
  • 参数校验。
  • 调用次数统计。

注意:上面的实现适用于同步函数。对于异步函数,需要正确处理 Promise 的完成、拒绝以及返回值,不能简单地认为函数返回就代表任务完成。