async函数与回调函数的区别详解

怎么入门文章编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《async函数与回调函数的区别解析》，涉及到，有需要的可以收藏一下

async函数和回调函数是JavaScript中处理异步操作的不同方式，其核心区别在于代码结构、可读性和错误处理机制。1. 回调函数通过将函数作为参数传递，在异步操作完成后执行，但容易导致“回调地狱”，代码嵌套深、逻辑混乱；2. async/await基于Promise，使用同步风格编写异步代码，提升可读性和维护性；3. 错误处理方面，回调需在每个函数内手动检查err参数，而async/await通过try...catch集中捕获错误；4. 在新项目或支持Promise的API中优先使用async/await，而在与遗留系统交互或事件监听等场景下仍需回调函数。

async函数和回调函数都是JavaScript中处理异步操作的方式，但它们在代码结构、可读性以及错误处理上有着显著的区别。简单来说，async/await是基于Promise的语法糖，它让异步代码看起来和写起来更像同步代码，极大地提升了可读性和维护性；而回调函数则是将一个函数作为参数传递给另一个函数，在异步操作完成后被调用执行。

解决方案

谈到JavaScript里的异步编程，我脑子里首先浮现的就是那条漫长的演进之路。从最初的纯回调，到Promise的出现，再到如今普遍使用的async/await，每一步都旨在让开发者写出更清晰、更易维护的代码。

回调函数（Callbacks）

回调函数是最早也是最直接的异步处理方式。它的核心思想是“我把这个任务交给你，等任务完成了，你再来通知我，或者帮我执行一个我指定的操作”。

比如，我们去读取一个文件：

const fs = require('fs');

fs.readFile('my_file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('读取文件出错啦:', err);
    return;
  }
  console.log('文件内容是:', data);
  // 如果这里还要处理文件内容，比如再写入另一个文件
  fs.writeFile('new_file.txt', data.toUpperCase(), (err) => {
    if (err) {
      console.error('写入文件出错:', err);
      return;
    }
    console.log('文件写入成功！');
  });
});

这种方式在处理简单异步任务时非常直观，但一旦异步操作需要连续依赖，或者涉及到多个并行任务，就会迅速陷入“回调地狱”（Callback Hell），代码缩进越来越深，逻辑变得难以追踪和理解。错误处理也常常需要每个回调函数内部都检查err参数，容易遗漏。

async函数与await（Async/Await）

async/await是ES2017引入的特性，它建立在Promise之上，旨在解决回调地狱和Promise链条过长的问题。一个async函数总是返回一个Promise，而await关键字只能在async函数内部使用，它会暂停async函数的执行，直到它等待的Promise被解决（resolved）或拒绝（rejected）。

我们用async/await来重写上面的文件读写操作（假设fs.promises可用，或者我们自己封装成Promise）：

const fs = require('fs').promises; // 使用fs模块的Promise版本

async function processFile() {
  try {
    const data = await fs.readFile('my_file.txt', 'utf8');
    console.log('文件内容是:', data);

    const transformedData = data.toUpperCase();
    await fs.writeFile('new_file.txt', transformedData);
    console.log('文件写入成功！');
  } catch (err) {
    console.error('处理文件时出错了:', err);
  }
}

processFile();

是不是感觉代码瞬间“扁平”了许多？它看起来就像同步代码一样，从上到下顺序执行，这大大提升了代码的可读性和逻辑清晰度。错误处理也变得非常自然，一个简单的try...catch块就能捕获整个异步序列中的任何错误，这与同步代码的错误处理方式完全一致。

核心差异与选择

在我看来，async/await之所以能成为现代JavaScript异步编程的首选，关键在于它把异步的“不确定性”包装成了同步的“确定性”。你不再需要关注回调什么时候被调用，或者Promise什么时候解决，你只需要await，然后代码就会像正常的顺序执行一样继续。

选择哪个，很大程度上取决于你面对的API和项目语境。如果面对的是老旧的、只支持回调的API，你可能需要用util.promisify或者手动封装成Promise再使用async/await。但对于新的项目或支持Promise的API，async/await无疑是更优的选择。它让我们的思维流程更接近人类的自然思考方式，减少了认知负担。

为什么说 async/await 解决了回调地狱问题？

回调地狱（Callback Hell），又称“厄运金字塔”（Pyramid of Doom），是早期JavaScript异步编程中一个让人头疼的现象。当多个异步操作需要串联执行，并且后一个操作依赖前一个操作的结果时，代码就会形成层层嵌套的缩进，像金字塔一样向右延伸。

举个例子，假设我们要：

1. 读取用户数据。
2. 根据用户ID获取订单列表。
3. 对每个订单，获取其详细商品信息。
4. 最后汇总并展示。

如果用纯回调，代码可能会变成这样：

// 伪代码，展示结构
getUserData(userId, (err, userData) => {
  if (err) { /* 处理错误 */ return; }
  getOrders(userData.id, (err, orders) => {
    if (err) { /* 处理错误 */ return; }
    orders.forEach(order => {
      getProducts(order.id, (err, products) => {
        if (err) { /* 处理错误 */ return; }
        // 更多嵌套处理...
        displayResults(userData, orders, products);
      });
    });
  });
});

这种结构不仅难以阅读，而且维护起来更是噩梦。任何一个环节出错，都需要在对应的回调中单独处理错误，逻辑分散。

async/await通过将基于Promise的异步流转换为看起来像同步的线性代码流，彻底“拍平”了这种嵌套结构。每个await表达式都会暂停当前async函数的执行，直到它等待的Promise解决，然后返回值，代码再从暂停的地方继续执行。

用async/await重写上面的逻辑：

async function fetchAndDisplayUserData(userId) {
  try {
    const userData = await getUserData(userId);
    const orders = await getOrders(userData.id);

    const allProducts = [];
    for (const order of orders) {
      const products = await getProducts(order.id);
      allProducts.push(...products);
    }

    displayResults(userData, orders, allProducts);
  } catch (error) {
    console.error('数据获取或展示过程中发生错误:', error);
  }
}

fetchAndDisplayUserData('someUserId');

可以看到，代码从左到右，从上到下，一步步清晰地执行，完全避免了多层嵌套。错误处理也集中在最外层的try...catch块中，任何一个await表达式抛出的错误（即Promise被拒绝）都会被捕获，这让错误处理变得异常简洁和高效。这正是async/await解决回调地狱的根本原因：它将复杂的异步依赖链条，转化为人类大脑更容易理解的顺序执行逻辑。

async/await 的错误处理机制与传统回调有何不同？

错误处理在异步编程中至关重要，它直接关系到应用的健壮性和用户体验。async/await和传统回调在错误处理上有着显著的区别，这通常是开发者偏爱async/await的重要原因之一。

传统回调的错误处理：错误优先回调

在Node.js环境中，回调函数通常遵循“错误优先”（Error-first callback）的约定。这意味着回调函数的第一个参数通常是Error对象，如果操作成功，这个参数是null或undefined；如果操作失败，它则包含错误信息。

// 传统回调错误处理示例
doSomethingAsync(arg1, (err, result) => {
  if (err) {
    console.error('操作1失败:', err);
    return; // 必须手动返回，防止后续代码执行
  }
  doAnotherThingAsync(result, (err2, finalResult) => {
    if (err2) {
      console.error('操作2失败:', err2);
      return;
    }
    console.log('所有操作成功:', finalResult);
  });
});

这种模式的缺点很明显：

1. 重复性高：每个回调函数内部都需要手动检查err参数，并编写相同的错误处理逻辑（如if (err) { ... return; }）。
2. 容易遗漏：如果某个回调忘记检查err，或者忘记return，可能会导致后续逻辑在错误状态下继续执行，引发更难以调试的问题。
3. 分散性：错误处理逻辑散布在代码的各个角落，难以集中管理和观察。

async/await的错误处理：try...catch

async/await的错误处理机制与同步代码如出一辙，它利用了JavaScript原生的try...catch语句。当一个await表达式等待的Promise被拒绝（rejected）时，这个拒绝的值会被作为异常抛出，然后可以被最近的try...catch块捕获。

// async/await 错误处理示例
async function performComplexOperation() {
  try {
    const step1Result = await doSomethingAsync(arg1); // 如果Promise拒绝，会抛出错误
    const step2Result = await doAnotherThingAsync(step1Result); // 同理

    console.log('所有操作成功:', step2Result);
    return step2Result;
  } catch (error) {
    // 任何一个await抛出的错误都会在这里被捕获
    console.error('复杂操作中发生错误:', error);
    // 可以选择重新抛出错误，或者返回一个默认值等
    throw error; // 重新抛出，让上层调用者处理
  }
}

// 调用示例
performComplexOperation()
  .then(data => console.log('最终数据:', data))
  .catch(err => console.error('顶层捕获:', err));

这种方式的优势非常明显：

1. 集中管理：一个try...catch块可以捕获整个异步序列中的所有错误，错误处理逻辑高度集中。
2. 可读性强：它遵循了我们处理同步代码错误的方式，更符合直觉。
3. 不易遗漏：只要await的Promise拒绝，错误就会自动被抛出并被catch捕获，不需要手动检查。
4. 更自然的流程控制：当错误发生时，代码会立即跳到catch块，不再执行try块中剩余的代码，这与同步错误处理行为一致。

在我看来，async/await的错误处理是其最大的亮点之一。它不仅简化了代码，更重要的是，它降低了出错的可能性，并让开发者能够以更统一、更高效的方式来思考和管理异步操作中的异常情况。

在实际项目中，何时优先选择 async/await，何时仍需考虑回调函数？

在现代JavaScript开发中，async/await无疑是处理异步操作的首选。它带来的代码可读性和可维护性提升是巨大的。然而，这并不意味着回调函数就完全没有用武之地了。在实际项目中，我通常会根据以下几个因素来决定使用哪种方式：

优先选择 async/await 的场景：

1. 新项目或使用现代API时： 几乎所有新的JavaScript API（如fetch、WebSockets、IndexedDB等）都原生支持Promise，或者很容易被Promise化。在这些场景下，直接使用async/await能让代码最简洁、最符合现代编程习惯。
2. 涉及多个串行异步操作时： 当一个异步操作的结果是下一个异步操作的输入时，async/await能将这种依赖链条扁平化，避免回调地狱，让逻辑流程一目了然。例如，用户认证后获取其个人信息，再根据信息查询其订单。
3. 需要统一错误处理时： async/await结合try...catch提供了同步代码般的错误处理机制，能够集中捕获和处理整个异步序列中的错误，大大简化了错误处理逻辑，提升了代码的健壮性。
4. 与Promise-based库/框架集成时： 大多数现代的JavaScript库和框架（如Axios、Mongoose等）都返回Promise。与这些库协同工作时，async/await能提供最优雅的集成方式。
5. 提高代码可读性和可维护性： 这是最核心的驱动力。当团队协作、项目规模较大时，清晰的代码是降低沟通成本、减少bug的关键。

仍需考虑回调函数的场景：

1. 与遗留系统或老旧API交互时： 某些Node.js核心模块的旧版本（例如，fs模块的早期API，不带.promises后缀的）或者一些老旧的第三方库可能只提供回调接口。在这种情况下，如果你不想引入util.promisify或者手动封装Promise的额外开销（尽管通常推荐这样做），直接使用回调可能更直接。

   // 假设一个老旧的数据库查询接口
   db.query('SELECT * FROM users', (err, rows) => {
     if (err) { /* handle error */ }
     // process rows
   });

2. 事件监听器： 事件驱动编程模型中，回调函数是核心。例如，DOM事件监听器、Node.js的EventEmitter。

   document.getElementById('myButton').addEventListener('click', () => {
     console.log('按钮被点击了！');
   });
   
   const EventEmitter = require('events');
   const myEmitter = new EventEmitter();
   myEmitter.on('userLoggedIn', (userId) => {
     console.log(`用户 ${userId} 登录了。`);
   });
   myEmitter.emit('userLoggedIn', 'Alice');

   在这种场景下，回调函数是自然且必要的。虽然你可以将事件触发后的处理逻辑封装在async函数中，但事件监听本身仍是回调模式。

3. 非常简单的、单步的异步操作： 对于一些极其简单的异步操作，如果引入async/await反而显得代码冗余，直接使用回调可能更简洁。但这通常很少见，因为async/await的语法开销已经很小了。

总的来说，我个人的经验是，在绝大多数现代JavaScript开发场景中，都应该优先考虑async/await。它不仅让代码看起来更“同步”，更容易理解，也极大地提升了错误处理的效率。只有在确实需要与只支持回调的遗留系统交互，或者在事件驱动的特定场景下，才考虑直接使用回调函数。即便如此，很多时候我们也会选择将回调接口Promise化，以便能继续享受async/await带来的便利。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《async函数与回调函数的区别详解》文章吧，也可关注golang学习网公众号了解相关技术文章。