回调函数模式

回调函数模式的基本概念

回调函数模式是Node.js异步编程的核心机制之一。当一个函数需要等待某个操作完成后再执行时，可以将这个函数作为参数传递给另一个函数，待操作完成后再调用它。这种模式在I/O操作、定时器等场景中尤为常见。

function readFile(callback) {
  // 模拟异步读取文件
  setTimeout(() => {
    const data = "文件内容";
    callback(null, data);
  }, 1000);
}

readFile((err, data) => {
  if (err) {
    console.error("读取文件出错:", err);
    return;
  }
  console.log("读取到的数据:", data);
});

回调函数的工作原理

在Node.js中，回调函数通过事件循环机制工作。当异步操作开始时，它会被放入事件队列，主线程继续执行后续代码。当异步操作完成后，回调函数被推入调用栈执行。

console.log("开始");

setTimeout(() => {
  console.log("回调执行");
}, 0);

console.log("结束");

// 输出顺序:
// 开始
// 结束
// 回调执行

错误优先回调模式

Node.js约定回调函数的第一个参数为错误对象，这种模式称为"错误优先回调"（Error-first Callback）。如果操作成功，错误参数为null或undefined；如果失败，则传递错误对象。

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

divide(10, 2, (err, result) => {
  if (err) {
    console.error("计算出错:", err.message);
    return;
  }
  console.log("计算结果:", result);
});

回调地狱问题

当多个异步操作需要顺序执行时，嵌套的回调会导致代码难以维护，这种现象称为"回调地狱"（Callback Hell）。

fs.readFile('file1.txt', 'utf8', (err, data1) => {
  if (err) throw err;
  fs.readFile('file2.txt', 'utf8', (err, data2) => {
    if (err) throw err;
    fs.writeFile('combined.txt', data1 + data2, (err) => {
      if (err) throw err;
      console.log('文件合并成功');
    });
  });
});

解决回调地狱的方法

命名函数

将回调函数提取为命名函数可以减少嵌套层级。

function handleFile1(err, data1) {
  if (err) throw err;
  fs.readFile('file2.txt', 'utf8', handleFile2.bind(null, data1));
}

function handleFile2(data1, err, data2) {
  if (err) throw err;
  fs.writeFile('combined.txt', data1 + data2, handleWrite);
}

function handleWrite(err) {
  if (err) throw err;
  console.log('文件合并成功');
}

fs.readFile('file1.txt', 'utf8', handleFile1);

使用控制流库

如async.js这样的库提供了更优雅的处理方式。

const async = require('async');

async.waterfall([
  (callback) => {
    fs.readFile('file1.txt', 'utf8', callback);
  },
  (data1, callback) => {
    fs.readFile('file2.txt', 'utf8', (err, data2) => {
      callback(err, data1, data2);
    });
  },
  (data1, data2, callback) => {
    fs.writeFile('combined.txt', data1 + data2, callback);
  }
], (err) => {
  if (err) throw err;
  console.log('文件合并成功');
});

Node.js核心模块中的回调模式

Node.js的许多核心API都采用回调模式设计，特别是文件系统、网络等I/O密集型操作。

文件系统示例

const fs = require('fs');

fs.stat('example.txt', (err, stats) => {
  if (err) {
    console.error('获取文件状态出错:', err);
    return;
  }
  console.log(`文件大小: ${stats.size}字节`);
});

HTTP服务器示例

const http = require('http');

const server = http.createServer((req, res) => {
  // 这里的回调函数处理每个HTTP请求
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
});

server.listen(3000, () => {
  console.log('服务器运行在 http://localhost:3000/');
});

回调函数的性能考虑

虽然回调模式非常适合I/O密集型应用，但需要注意：

1. 过多的嵌套回调会影响性能
2. 错误处理不当可能导致内存泄漏
3. 回调函数中的同步操作会阻塞事件循环

// 不好的实践 - 同步操作在回调中
function processData(data, callback) {
  // 耗时的同步操作
  const result = expensiveSyncOperation(data);
  callback(null, result);
}

// 改进方案 - 使用setImmediate或process.nextTick
function betterProcessData(data, callback) {
  setImmediate(() => {
    const result = expensiveSyncOperation(data);
    callback(null, result);
  });
}

回调模式与Promise/Async-Await的比较

虽然现代JavaScript推荐使用Promise和async/await，但理解回调模式仍然很重要，因为：

1. 许多遗留代码和库仍使用回调
2. 某些场景下回调可能更直接
3. 理解回调有助于深入理解异步编程

// 回调版本
function oldSchool(callback) {
  doAsyncThing((err, result) => {
    if (err) return callback(err);
    doAnotherAsyncThing(result, callback);
  });
}

// Promise版本
function modern() {
  return doAsyncThing()
    .then(doAnotherAsyncThing);
}

// Async/Await版本
async function newest() {
  const result = await doAsyncThing();
  return await doAnotherAsyncThing(result);
}

回调函数的进阶模式

可取消回调

function fetchData(callback) {
  const timer = setTimeout(() => {
    callback(null, "数据");
  }, 1000);
  
  return () => {
    clearTimeout(timer);
    callback(new Error("操作已取消"));
  };
}

const cancel = fetchData((err, data) => {
  if (err) {
    console.error(err.message);
    return;
  }
  console.log("收到数据:", data);
});

// 取消操作
cancel();

多回调支持

function eventEmitter() {
  const callbacks = [];
  
  return {
    on(cb) {
      callbacks.push(cb);
    },
    emit(data) {
      callbacks.forEach(cb => cb(data));
    }
  };
}

const emitter = eventEmitter();
emitter.on(data => console.log("回调1:", data));
emitter.on(data => console.log("回调2:", data.toUpperCase()));
emitter.emit("测试数据");

回调函数的最佳实践

1. 总是检查错误参数
2. 避免在回调中抛出异常
3. 保持回调简单，复杂逻辑提取到单独函数
4. 文档化回调的参数和返回值
5. 考虑使用工具函数处理常见模式

// 使用工具函数处理错误
function handleError(err) {
  if (!err) return false;
  console.error("操作失败:", err.message);
  return true;
}

function doSomething(callback) {
  asyncOperation((err, result) => {
    if (handleError(err)) return;
    callback(null, process(result));
  });
}