返回专栏
· 18 分钟阅读

回调函数


一、什么是回调函数

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

它的核心不在于函数如何定义,而在于函数的调用权被交给了其他代码。

例如 JavaScript:

function processData(data, callback) {
    const result = data.toUpperCase();
    callback(result);
}

function printResult(value) {
    console.log(value);
}

processData("hello", printResult);

执行过程:

  1. 定义 printResult 函数。
  2. 调用 processData,将 printResult 作为参数传入。
  3. processData 完成数据处理。
  4. processData 主动调用 callback。
  5. printResult 执行并输出结果。

这里的 printResult 就是回调函数,processData 是回调函数的调用方。

1. 回调函数的基本特征

特征 说明
函数作为参数 可以将函数传递给其他函数
延迟调用 接收方不一定立即执行回调
调用权转移 回调由接收方决定何时调用
行为可替换 可以传入不同函数改变处理逻辑
扩展性 不修改原函数主体即可扩展行为

2. 回调函数与普通函数

普通函数通常由调用者直接发起调用,而回调函数由其他函数或系统在约定的时机调用。

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

// 普通函数调用
sayHello();

// 作为回调函数传递
function execute(callback) {
    callback();
}

execute(sayHello);

需要注意:回调函数并不是一种特殊的函数类型。

从语言层面看,它仍然是普通函数,只是因为传递和调用方式不同,被称为回调函数。


二、回调函数的工作原理

回调函数依赖于语言的函数对象、参数传递和函数调用机制。

其基本原理可以分为三个阶段:

  1. 函数定义:创建可执行的函数对象。
  2. 函数传递:将函数对象作为参数传递给其他函数。
  3. 函数调用:接收方在约定时机调用该函数。

1. 基本执行流程

flowchart TD
    A["定义回调函数"] --> B["定义接收回调的函数"]
    B --> C["调用接收函数"]
    C --> D["传递回调函数引用"]
    D --> E["接收方执行自身逻辑"]
    E --> F["调用回调函数"]
    F --> G["回调函数执行"]
    G --> H["返回或继续后续逻辑"]

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

2. 回调函数的调用时机

回调函数的调用时机由接收方决定,并不局限于函数执行结束后。

常见调用时机:

调用时机 典型场景
立即调用 数据处理完成后执行
条件满足时 校验通过、状态变化
循环过程中 数组遍历、集合处理
异步任务完成后 网络请求、文件读取
事件发生时 点击、键盘输入、消息到达
定时触发 定时器、周期任务

例如:

function validate(value, callback) {
    if (value.length > 0) {
        callback(true);
    } else {
        callback(false);
    }
}

validate("hello", (result) => {
    console.log("验证结果:", result);
});

这里的回调函数只有在 validate 执行到对应分支时才会被调用。

3. 回调函数的参数传递

回调函数可以接收调用方传入的数据。

function calculate(a, b, callback) {
    const result = a + b;
    callback(result);
}

calculate(10, 20, function(result) {
    console.log(result);
});

回调函数的参数由调用方决定,双方需要遵守约定的参数结构。

在实际开发中,通常需要明确:

  • 参数数量。
  • 参数顺序。
  • 参数类型。
  • 是否允许为空。
  • 返回值是否有意义。
  • 是否可能抛出异常。

这些约定构成了回调函数的调用契约。


三、回调函数的常见类型

回调函数可以根据执行时机和执行方式进行分类。

1. 同步回调(Synchronous Callback)

同步回调是指回调函数在当前调用栈中执行,通常在接收函数返回之前完成。

function process(callback) {
    console.log("开始处理");
    callback();
    console.log("处理结束");
}

process(() => {
    console.log("执行回调");
});

输出:

开始处理
执行回调
处理结束

执行特点:

  • 调用方直接调用回调。
  • 回调执行期间,当前调用流程通常会等待其返回。
  • 回调执行完成后,接收函数继续执行。
  • 回调异常可能沿当前调用栈向上传播。

常见场景:

  • 数组遍历。
  • 数据转换。
  • 排序比较函数。
  • 条件判断。
  • 同步数据处理。

例如 JavaScript 的 map:

const numbers = [1, 2, 3];

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

console.log(result);

map 接收一个回调函数,并在遍历数组时同步调用它。

2. 异步回调(Asynchronous Callback)

异步回调是指回调函数不会在当前调用流程中立即执行,而是在异步任务完成或指定事件发生后执行。

例如:

console.log("开始");

setTimeout(() => {
    console.log("异步回调");
}, 1000);

console.log("结束");

输出:

开始
结束
异步回调

异步回调通常涉及事件循环、任务队列或运行时调度机制。

执行过程:

flowchart TD
    A["执行当前代码"] --> B["提交异步任务"]
    B --> C["继续执行后续代码"]
    C --> D["异步任务完成"]
    D --> E["回调进入任务调度队列"]
    E --> F["等待调用栈满足执行条件"]
    F --> G["事件循环调度回调"]
    G --> H["执行回调函数"]

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

需要注意:

异步回调不意味着一定创建新线程。

以 JavaScript 浏览器环境为例,定时器、网络请求等异步操作由运行时及相关底层机制协调,回调最终由事件循环安排执行。回调本身通常仍在 JavaScript 主线程中执行。

3. 一次性回调与重复回调

按照调用次数,还可以区分为:

类型 说明 示例
一次性回调 只执行一次 单次网络请求完成
多次回调 可以执行多次 数据流、进度通知
条件回调 满足条件时执行 校验成功、状态变化
周期回调 按周期重复执行 定时任务

例如:

function download(callback) {
    callback(25);
    callback(50);
    callback(75);
    callback(100);
}

download((progress) => {
    console.log(`下载进度:${progress}%`);
});

回调函数被调用多次,因此不能默认回调只会执行一次。


四、回调函数的典型应用场景

回调函数是很多编程语言和框架的基础机制。

1. 数组遍历与数据处理

通过回调函数将具体处理逻辑交给集合操作方法。

JavaScript:

const users = [
    { name: "Alice", age: 20 },
    { name: "Bob", age: 25 },
    { name: "Charlie", age: 30 }
];

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

console.log(names);

map 不需要知道业务要提取什么字段,只负责遍历并调用传入的回调函数。

这种方式实现了集合遍历机制与业务处理逻辑的分离。

2. 事件处理

事件驱动程序通过注册回调函数响应外部事件。

document.addEventListener("click", (event) => {
    console.log("发生点击事件", event);
});

这里:

  • addEventListener 是事件注册接口。
  • click 是事件类型。
  • 回调函数是事件处理逻辑。
  • event 是事件发生时传递的数据。

事件发生后,浏览器运行时负责调度对应的事件处理函数。

事件回调的典型流程:

flowchart TD
    A["注册事件监听器"] --> B["等待事件发生"]
    B --> C["用户触发事件"]
    C --> D["浏览器生成事件对象"]
    D --> E["查找已注册的监听器"]
    E --> F["调度事件回调"]
    F --> G["执行事件处理逻辑"]
    G --> H["更新页面或业务状态"]

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

3. 网络请求

在传统异步编程中,可以通过回调处理网络请求结果。

function requestData(url, callback) {
    fetch(url)
        .then(response => {
            if (!response.ok) {
                throw new Error("请求失败");
            }

            return response.json();
        })
        .then(data => {
            callback(null, data);
        })
        .catch(error => {
            callback(error, null);
        });
}

requestData("/api/users", (error, data) => {
    if (error) {
        console.error(error);
        return;
    }

    console.log(data);
});

这里采用了错误优先的回调约定:

callback(error, result);

约定:

  • 第一个参数表示错误。
  • 第二个参数表示成功结果。
  • 成功时错误参数通常为 null。
  • 失败时结果参数通常为 null。

这种形式在 Node.js 传统异步 API 中较为常见。

注意:上面的 fetch 实际上基于 Promise,示例只是将 Promise 结果封装成回调接口,并不是底层网络 API 本身采用回调风格。

4. 定时任务

通过回调函数指定定时任务需要执行的逻辑。

setInterval(() => {
    console.log("定时执行任务");
}, 2000);

定时器负责调度,回调函数负责具体业务逻辑。

需要注意,定时器触发时间并不保证回调精确执行。主线程繁忙、事件循环调度和运行时负载都可能造成延迟。

5. 插件与框架扩展

框架可以预留回调接口,让使用者自定义执行逻辑。

function createButton(label, onClick) {
    return {
        label,
        click() {
            if (typeof onClick === "function") {
                onClick();
            }
        }
    };
}

const button = createButton("提交", () => {
    console.log("执行提交操作");
});

button.click();

框架负责定义执行时机,使用者负责提供业务行为。

这种设计常见于:

  • UI 组件库。
  • 插件系统。
  • 生命周期钩子。
  • 中间件机制。
  • 框架扩展点。

五、回调函数与控制反转(IoC)

回调函数最重要的设计价值之一,是实现控制反转(Inversion of Control,IoC)。

1. 什么是控制反转

传统调用方式中,业务代码直接控制函数调用过程。

function saveData() {
    console.log("保存数据");
}

function handleRequest() {
    saveData();
}

handleRequest 主动决定何时调用 saveData。

使用回调函数后,可以将具体行为交给外部:

function handleRequest(callback) {
    console.log("处理请求");
    callback();
}

handleRequest(() => {
    console.log("保存数据");
});

此时:

  • handleRequest 控制执行时机。
  • 外部调用者提供具体行为。
  • 具体行为由接收方在适当时机触发。

这就是控制反转的一个典型表现。

2. 控制权的变化

flowchart TD
    subgraph OLD["传统直接调用"]
        A["业务代码"] --> B["调用具体函数"]
        B --> C["执行具体逻辑"]
    end

    subgraph NEW["回调机制"]
        D["外部调用者"] --> E["传入回调函数"]
        E --> F["框架或接收方"]
        F --> G["决定调用时机"]
        G --> H["执行回调逻辑"]
    end

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

3. 回调与依赖注入的关系

回调函数和依赖注入(Dependency Injection,DI)存在联系,但两者并不等价。

对比维度 回调函数 依赖注入
核心目的 将行为交给外部提供 将依赖交给外部提供
注入对象 通常是函数行为 对象、接口、函数等依赖
典型场景 事件处理、异步通知 服务、仓储、配置管理
设计重点 何时调用、如何传参 依赖如何创建和管理

回调函数可以作为依赖注入的一种实现形式,但依赖注入还包括构造器注入、属性注入、方法注入等方式。


六、不同编程语言中的回调函数

回调函数不是 JavaScript 独有的机制。只要语言支持将函数或可调用对象传递给其他代码,就可以实现类似设计。

1. JavaScript

JavaScript 将函数视为一等公民,可以直接传递函数、匿名函数和箭头函数。

function execute(callback) {
    callback("JavaScript");
}

execute((name) => {
    console.log(name);
});

常见应用:

  • 事件监听。
  • 数组操作。
  • 定时器。
  • 异步请求。
  • Promise 链式处理中的回调。

2. Python

Python 中函数是一等对象,可以直接作为参数传递。

def execute(callback):
    callback("Python")

def print_message(name):
    print(name)

execute(print_message)

也可以使用 Lambda 表达式:

execute(lambda name: print(name))

常见应用:

  • map()、filter()。
  • 排序函数的 key 参数。
  • GUI 事件处理。
  • 装饰器和框架钩子。
  • 异步任务回调。

3. Java

Java 可以通过函数式接口实现回调机制。

import java.util.function.Consumer;

public class CallbackDemo {

    static void execute(Consumer<String> callback) {
        callback.accept("Java");
    }

    public static void main(String[] args) {
        execute(message -> {
            System.out.println(message);
        });
    }
}

Java 中常用的回调形式包括:

类型 用途
Runnable 无参数、无返回值
Consumer<T> 接收参数、无返回值
Function<T, R> 接收参数并返回结果
Predicate<T> 接收参数并返回布尔值
自定义接口 定义特定回调契约

Java 的回调不一定必须使用函数式接口,也可以通过普通接口和匿名内部类实现。

4. C++

C++ 可以通过函数指针、函数对象和 Lambda 表达式实现回调。

函数指针:

#include <iostream>

void printMessage() {
    std::cout << "C++ callback" << std::endl;
}

void execute(void (*callback)()) {
    callback();
}

int main() {
    execute(printMessage);
    return 0;
}

Lambda 表达式:

#include <iostream>
#include <functional>

void execute(const std::function<void()>& callback) {
    callback();
}

int main() {
    execute([]() {
        std::cout << "Lambda callback" << std::endl;
    });

    return 0;
}

C++ 中常见的回调实现:

  • 函数指针。
  • 函数对象(Functor)。
  • Lambda 表达式。
  • std::function。
  • 模板参数与可调用对象。

需要注意,std::function 是类型擦除后的可调用对象包装器,并不是回调机制本身。

5. Go

Go 使用函数类型作为参数实现回调。

package main

import "fmt"

func execute(callback func(string)) {
    callback("Go")
}

func main() {
    execute(func(name string) {
        fmt.Println(name)
    })
}

Go 中常见的回调应用:

  • HTTP 处理器。
  • 排序比较函数。
  • 中间件。
  • 并发任务完成通知。
  • 函数式选项模式。

6. Rust

Rust 可以使用泛型约束和闭包实现回调。