回调函数（Callback Function）一. 回调函数是什么？定义回调函数（Callback Function

一. 回调函数是什么？

定义
- 回调函数（Callback Function）是一个通过函数指针（或引用）传递给其他函数的函数。
- 它在特定条件满足时（如事件触发、异步操作完成）被调用。即在某个操作完成后被调用的函数。它是异步编程的核心。
核心思想
- “你调用我，我稍后调用你”
- 将代码逻辑的控制权交给另一个函数，实现灵活的逻辑扩展。
历史背景与现代演进
- 早期解决方案：回调是异步编程最直接的实现方式，简单且无需复杂语法支持。
- 现代替代方案：Promise、async/await 通过更优雅的语法解决了回调地狱问题，但底层仍依赖回调机制。
- 不可替代性：大量遗留代码和底层API（如浏览器API、Node.js 核心模块）仍基于回调。

二. 回调函数的用途

1. 处理异步操作(核心)：处理非阻塞操作

JavaScript 是单线程语言，意味着它一次只能执行一个任务。如果遇到耗时操作（如网络请求、文件读写），线程会被阻塞，导致页面卡死。回调函数让异步操作成为可能：主线程发起异步任务后继续执行其他代码，任务完成时通过回调通知结果。

示例：无回调的同步 vs 有回调的异步
```
// ❌ 同步方式（阻塞线程）
const data = syncDownloadFile("url"); // 假设耗时3秒
console.log("下载完成"); // 3秒后才能执行

// ✅ 异步回调（非阻塞）
asyncDownloadFile("url", (data) => {
  console.log("下载完成", data);
});
console.log("继续执行其他任务"); // 立即执行
```

2. 事件驱动编程：响应事件

在图形界面（如浏览器、桌面应用）中，用户操作（点击、输入）或系统事件（定时器、网络响应）无法预知何时发生。回调函数允许程序“订阅”事件，事件触发时自动执行逻辑。
- 示例：按钮点击事件
```
button.addEventListener("click", () => {
  console.log("按钮被点击了！"); // 点击时才执行回调
});
```

3. 定制逻辑：允许调用方自定义代码逻辑（如数组遍历 `array.forEach(callback)`）。

通过将具体操作抽象为回调函数，实现一次编写遍历逻辑，多次复用：

// 通用遍历函数（接收回调）
function myForEach(arr, callback) {
  for (let i = 0; i < arr.length; i++) {
    callback(arr[i]); // 将当前元素交给回调处理
  }
}

const numbers = [1, 2, 3];

// 场景1：打印元素
myForEach(numbers, (num) => {
  console.log(num); // 输出：1 2 3
});

// 场景2：计算平方
myForEach(numbers, (num) => {
  console.log(num ** 2); // 输出：1 4 9
});

// 场景3：过滤偶数
myForEach(numbers, (num) => {
  if (num % 2 === 0) {
    console.log(num); // 输出：2
  }
});

优势：
- 复用性：遍历逻辑只需实现一次。
- 灵活性：调用方通过回调自由定义对每个元素的操作。
- 解耦：分离“遍历”和“处理”两个关注点。

4. 解耦代码：将功能模块分离，提高代码复用性。

回调函数将 “做什么” 和 “何时做” 分离。调用方通过回调定义具体逻辑，被调用方控制执行时机，实现代码复用和模块化。

示例：通用数据处理函数

// 通用函数：处理数据后通知回调
function processData(input, callback) {
  const result = input * 2;
  callback(result);
}

// 调用方自定义回调逻辑
processData(10, (result) => {
  console.log("结果：", result); // 输出：结果：20
});

5. 非阻塞I/O（关键性能优势）

- 在服务器端（如 Node.js），高并发场景需同时处理数千个请求。**回调函数配合非阻塞I/O模型**，让单线程通过事件循环高效处理多个任务，避免为每个请求创建线程的开销。

- **示例：Node.js 处理并发请求**
```javascript
// 伪代码：每个请求不阻塞其他请求
server.on("request", (request, response) => {
  readFileAsync(request.path, (err, data) => {
    response.send(data); // 文件读取完成后回调
  });
});
```

三. 基本结构

1. 单参数回调（仅处理成功）

function callback(data) { /* 仅处理成功时的数据 */ }

特点：
- 只关注成功结果（假设操作不会失败）。
- 不处理错误（错误可能通过其他方式抛出，如 throw 或全局捕获）。
适用场景：
- 同步操作（如数组遍历 array.map(callback)）。
- 明确不会出错的简单场景。

2. 错误优先回调（Error-First Callbacks）

(err, data) => {
  if (err) throw err;   // 处理错误
  console.log(data);    // 处理成功结果
}

特点：
- 约定俗成的规范（尤其在 Node.js 生态中广泛使用）。
- 第一个参数固定为错误对象 err，第二个参数为成功数据 data。
- 强制要求处理错误（必须检查 err 是否存在）。
适用场景：
- 异步操作（如文件读写、网络请求）。
- 需要显式处理错误的场景。
关键原则
- 统一的参数顺序（err 在前）以及在回调顶部先判断 if (err), 避免成功和错误逻辑混杂，提高代码可读性。
- 避免在回调中直接 throw， 异步回调中的 throw 无法被外层捕获,可能导致进程崩溃（如 Node.js 中）。应通过日志、返回或向上传递错误。
- 强制开发者处理错误， 避免“静默失败”。

四. 两种模式的转化

单参数回调 → 错误优先回调

若需要为单参数回调添加错误处理，可扩展参数：

function fetchData(callback) {
  someAsyncOperation((err, rawData) => {
    if (err) {
      callback(err); // 传递错误
    } else {
      const processedData = process(rawData);
      callback(null, processedData); // 成功时 err 为 null
    }
  });
}

错误优先回调 → Promise

现代编程中常用 Promise 或 async/await 替代回调：

function readFilePromise(path) {
  return new Promise((resolve, reject) => {
    fs.readFile(path, (err, data) => {
      if (err) reject(err);
      else resolve(data);
    });
  });
}

// 使用
readFilePromise('file.txt')
  .then(data => console.log(data))
  .catch(err => console.error(err));

实际开发中，建议在异步操作中始终使用 错误优先回调，而在现代项目中优先考虑 Promise 或 async/await 以提升代码可读性。

五. 同步回调 vs 异步回调

同步回调：立即执行，阻塞后续代码。

const numbers = [1, 2, 3];
numbers.forEach((num) => console.log(num)); // 同步依次输出

异步回调：在事件循环中延迟执行，不阻塞代码。

setTimeout(() => console.log("延迟1秒输出"), 1000); // 异步执行

六. 回调的局限性

回调地狱（Callback Hell）

问题：多层嵌套回调导致代码难以维护。

fetchData1((result1) => {
  fetchData2(result1, (result2) => {
    fetchData3(result2, (result3) => {
      // 更多嵌套...
    });
  });
});

解决方案：
- Promise：链式调用（.then().catch()）扁平化嵌套。
- async/await：用同步语法写异步代码，增强可读性。
- 事件监听模式：通过事件发射器（EventEmitter）管理多路回调。
- 模块化：拆分回调函数为独立函数。

七. 错误处理

Node.js 风格：错误优先回调（Error-First Callback）。

 function readFile(callback) {
   fs.readFile("file.txt", (err, data) => {
     if (err) {
       callback(err); // 优先返回错误
       return;
     }
     callback(null, data); // 成功时错误参数为null
   });
 }

为什么需要错误优先回调？

为了解决异步中的错误传递问题：

（1）同步错误：可通过 try/catch 捕获。

 try {
   const result = syncFunction();
 } catch (err) {
   console.error(err);
 }

（2）异步错误：无法用 try/catch 直接捕获，必须通过回调参数传递。

// 异步操作中，try/catch 无法捕获回调内的错误！
try {
  asyncFunction((err, data) => {
    if (err) throw err; // 这里抛出错误无法被外层 try/catch 捕获！
  });
} catch (err) {
  // 永远不会执行到这里
}

八. 应用场景

AJAX 请求：处理服务器返回数据。
定时任务：setTimeout/setInterval。
事件监听：element.addEventListener("click", callback)。
模块化设计：插件系统、中间件（如Express.js）。

回调函数（Callback Function）