JavaScript异步函数调用方法详解

一分耕耘，一分收获！既然都打开这篇《JavaScript中如何实现异步函数调用》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新文章相关的内容，希望对大家都有所帮助！

JavaScript中实现异步函数调用最现代且推荐的方式是使用async/await语法。1. 将函数声明为async以允许其内部使用await；2. 在async函数内使用await关键字等待Promise的解决，从而以同步方式处理异步操作；3. 通过try...catch结构捕获和处理错误；4. 利用Promise.all()或Promise.race()实现并发执行策略。async/await基于Promise，提升了代码可读性和可维护性，极大简化了异步逻辑的编写与调试。

在JavaScript中实现异步函数调用，最现代且推荐的方式是使用 async/await 语法。它建立在Promise之上，以一种更接近同步代码的写法来处理异步操作，极大提升了代码的可读性和可维护性。

解决方案

要实现异步函数调用，核心在于将函数声明为 async，然后在函数内部使用 await 关键字等待一个Promise的解决。

// 模拟一个异步操作，比如从服务器获取数据
function fetchData(url) {
    return new Promise(resolve => {
        setTimeout(() => {
            console.log(`从 ${url} 获取到数据了`);
            resolve({ id: 1, data: `这是从 ${url} 获取到的内容` });
        }, 1500); // 模拟网络延迟
    });
}

// 声明一个异步函数
async function processData() {
    console.log("开始处理数据...");
    try {
        // 使用 await 等待 fetchData Promise 的解决
        const result1 = await fetchData("https://api.example.com/data1");
        console.log("第一份数据处理完成:", result1);

        // 可以链式调用，下一个 await 会等待上一个完成后再执行
        const result2 = await fetchData("https://api.example.com/data2");
        console.log("第二份数据处理完成:", result2);

        // 如果有错误，会被 try...catch 捕获
        // const result3 = await Promise.reject(new Error("模拟一个错误"));
        // console.log("第三份数据处理完成:", result3);

        console.log("所有数据处理完毕。");
        return "任务成功完成";
    } catch (error) {
        console.error("处理数据时发生错误:", error.message);
        return "任务失败";
    }
}

// 调用异步函数
processData().then(status => {
    console.log("最终任务状态:", status);
});

console.log("这行代码会先执行，因为 processData 是异步的。");

这段代码展示了 async/await 的基本用法：async 标记函数为异步，允许其内部使用 await；await 暂停当前 async 函数的执行，直到它后面的Promise解决（resolve）或拒绝（reject）。如果Promise解决，await 会返回解决的值；如果Promise拒绝，它会抛出一个错误，这个错误可以用 try...catch 块捕获，就像处理同步错误一样。

为什么JavaScript需要异步函数？理解其单线程特性

JavaScript的运行机制，特别是它在浏览器中的表现，是单线程的。这意味着在任何给定时刻，JavaScript引擎只能执行一段代码。想象一下，如果我们在浏览器中执行一个耗时的网络请求，比如下载一个大文件，或者进行复杂的计算，如果这些操作是同步的，那么在操作完成之前，整个页面都会“冻结”，用户无法进行任何交互，这显然是不可接受的。

这就是异步编程的用武之地。通过异步操作，我们可以发起一个耗时任务，然后立即返回到主线程，让用户界面保持响应。当耗时任务完成后，它会通过回调函数、事件或者Promise（以及后来的async/await）通知我们结果。这就像你点了一份外卖，你不会一直站在门口等着，而是回去忙自己的事，等外卖小哥电话通知你到了再去取。早期我们用回调函数处理异步，但很快就遇到了“回调地狱”的问题，代码层层嵌套，难以阅读和维护。Promise的出现改善了这种情况，提供了链式调用的能力，而async/await则进一步将Promise的语法糖化，让异步代码看起来更像同步代码，大大降低了理解和编写异步逻辑的门槛。

Promise与Async/Await：它们之间的关系和选择

async/await 并不是凭空出现的魔法，它实际上是Promise的语法糖。这意味着，任何一个 await 表达式后面，本质上都跟着一个Promise对象。当你 await 一个非Promise的值时，JavaScript会隐式地将其包装成一个已解决的Promise。一个 async 函数的返回值，也总是一个Promise。如果你显式地 return 一个值，这个值会被包装成一个已解决的Promise；如果你 throw 一个错误，它会变成一个已拒绝的Promise。

那么，何时选择Promise，何时选择async/await呢？

• 创建和封装异步操作时，Promise依然是基础。 当你需要从头开始创建一个异步操作（比如封装一个Node.js的旧版回调API，或者自己写一个模拟网络请求），你通常会使用 new Promise() 构造函数。
• 消费和组织异步逻辑时，async/await 是首选。 当你已经有了Promise（无论是自己创建的还是API返回的），并且需要按照顺序执行它们，或者需要清晰地处理它们的成功和失败，async/await 提供了一种更直观、更线性的代码流。它消除了Promise链中 .then().catch() 的层层嵌套，使得调试也变得更容易，因为你可以像调试同步代码一样设置断点。

我个人觉得，async/await 极大地提升了开发体验。我记得刚接触JavaScript异步编程时，回调地狱简直是噩梦，Promise虽然改善了，但链式调用多了也挺考验眼力。async/await 出来后，代码一下子变得清爽多了，尤其是在处理多个依赖关系的异步操作时，那种“等待-获取结果-再等待-再获取”的逻辑，用 await 写起来简直是享受。当然，它也并非万能，对于需要并行执行的异步操作，Promise.all() 和 Promise.race() 依然是不可或缺的工具。

异步函数中的错误处理与并发执行策略

在异步函数中处理错误，async/await 的一个巨大优势是它允许我们使用传统的 try...catch 语句。当 await 后面的Promise被拒绝时，它会抛出一个错误，这个错误可以被最近的 try...catch 块捕获。这与同步代码的错误处理方式保持一致，极大地简化了异步错误处理的逻辑。

async function riskyOperation() {
    // 模拟一个可能失败的异步请求
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            const success = Math.random() > 0.5; // 50% 几率失败
            if (success) {
                resolve("操作成功！");
            } else {
                reject(new Error("操作失败，请重试。"));
            }
        }, 1000);
    });
}

async function performTask() {
    try {
        console.log("尝试执行一个有风险的操作...");
        const result = await riskyOperation();
        console.log("结果:", result);
    } catch (error) {
        console.error("捕获到错误:", error.message);
        // 这里可以进行错误恢复或通知用户
    } finally {
        console.log("任务尝试结束。"); // 无论成功失败都会执行
    }
}

performTask();

至于并发执行策略，虽然 await 会暂停当前 async 函数的执行，但这并不意味着我们不能在 async 函数内部进行并发操作。如果我们有多个独立的异步任务，它们之间没有依赖关系，我们不应该一个接一个地 await 它们，因为那样会变成串行执行，浪费时间。这时，Promise.all() 和 Promise.race() 就派上用场了。

• Promise.all(iterable): 当你需要等待所有Promise都成功解决时使用。它接受一个Promise数组，并返回一个新的Promise。只有当数组中的所有Promise都解决时，这个新的Promise才会解决，其结果是一个包含所有Promise解决值的数组。如果其中任何一个Promise被拒绝，Promise.all 返回的Promise会立即被拒绝，并带有第一个被拒绝的Promise的错误信息。

  async function fetchMultipleData() {
      console.log("开始并行获取多份数据...");
      try {
          const [data1, data2, data3] = await Promise.all([
              fetchData("https://api.example.com/item1"),
              fetchData("https://api.example.com/item2"),
              fetchData("https://api.example.com/item3")
          ]);
          console.log("所有数据并行获取完成:");
          console.log("数据1:", data1);
          console.log("数据2:", data2);
          console.log("数据3:", data3);
      } catch (error) {
          console.error("并行获取数据时发生错误:", error.message);
      }
  }
  fetchMultipleData();

• Promise.race(iterable): 当你只需要等待最快的那个Promise解决或拒绝时使用。它也接受一个Promise数组，并返回一个新的Promise。这个新的Promise会立即解决或拒绝，其结果是第一个解决或拒绝的Promise的值或错误。

  async function fastestResponse() {
      console.log("等待最快的响应...");
      try {
          const result = await Promise.race([
              new Promise(resolve => setTimeout(() => resolve("服务器A响应"), 2000)),
              new Promise(resolve => setTimeout(() => resolve("服务器B响应"), 1000)),
              new Promise((resolve, reject) => setTimeout(() => reject(new Error("服务器C超时")), 500)) // C最快，但失败
          ]);
          console.log("最快响应是:", result);
      } catch (error) {
          console.error("最快响应出现错误:", error.message);
      }
  }
  fastestResponse(); // 输出：最快响应出现错误: 服务器C超时

这些模式和工具的结合，让JavaScript的异步编程既强大又灵活，能够应对各种复杂的场景。理解它们的工作原理和适用场景，是写出高效、健壮异步代码的关键。

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