async和await入门教程详解

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习文章相关编程知识。下面本篇文章就来带大家聊聊《async和await入门教程详解》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

Async/await 的核心是简化异步操作写法，使代码更易读和维护。1. 它基于 Promise，通过 async 声明函数，内部使用 await 暂停执行直到 Promise resolve；2. 使用 try...catch 处理错误，提高可读性；3. 并发请求可通过 Promise.all() 实现；4. 循环中应避免串行 await，推荐用 Promise.all 并行处理；5. 虽提升开发体验，但需注意性能开销，如不必要的 async 函数或微任务延迟。

Async/await 的核心在于简化异步操作的写法，让异步代码看起来更像同步代码，提高代码的可读性和可维护性。它本质上是基于 Promise 的语法糖，使得处理 Promise 变得更加直观。

解决方案

Async 函数通过 async 关键字声明，内部可以使用 await 关键字。await 只能在 async 函数内部使用，它会暂停 async 函数的执行，直到 Promise 对象 resolve 才继续执行，并返回 Promise 的 resolve 值。

基本用法：

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching data:', error);
    throw error; // 重新抛出错误，让调用者处理
  }
}

fetchData()
  .then(data => console.log('Data:', data))
  .catch(error => console.error('Caught error:', error));

在这个例子中：

1. async function fetchData() 定义了一个异步函数。
2. await fetch('https://api.example.com/data') 暂停函数执行，直到 fetch 返回的 Promise resolve。
3. await response.json() 同样暂停函数执行，直到 response.json() 返回的 Promise resolve。
4. try...catch 块用于处理异步操作中可能发生的错误。throw error 保证错误能够被 fetchData().catch() 捕获。

Async/await 与 Promise 的关系：

Async/await 实际上是 Promise 的语法糖。上面的例子等价于：

function fetchData() {
  return fetch('https://api.example.com/data')
    .then(response => response.json())
    .then(data => {
      return data;
    })
    .catch(error => {
      console.error('Error fetching data:', error);
      throw error;
    });
}

fetchData()
  .then(data => console.log('Data:', data))
  .catch(error => console.error('Caught error:', error));

可以看出，使用 async/await 可以避免 Promise 的链式调用，使代码更加简洁易懂。虽然底层还是 Promise，但编写和阅读体验都得到了显著提升。

如何处理多个并发的异步请求？

可以使用 Promise.all() 来并发执行多个异步请求。Promise.all() 接收一个 Promise 数组作为参数，并返回一个新的 Promise，这个新的 Promise 在所有 Promise 都 resolve 时 resolve，或者在任何一个 Promise reject 时 reject。

async function fetchMultipleData() {
  try {
    const [data1, data2] = await Promise.all([
      fetch('https://api.example.com/data1').then(res => res.json()),
      fetch('https://api.example.com/data2').then(res => res.json())
    ]);
    console.log('Data 1:', data1);
    console.log('Data 2:', data2);
    return { data1, data2 };
  } catch (error) {
    console.error('Error fetching multiple data:', error);
    throw error;
  }
}

fetchMultipleData()
  .then(result => console.log('Result:', result))
  .catch(error => console.error('Caught error:', error));

这个例子中，Promise.all() 并发执行两个 fetch 请求。只有当两个请求都成功返回数据后，await Promise.all() 才会 resolve，并将两个请求的结果以数组的形式返回。如果其中任何一个请求失败，Promise.all() 就会 reject，并抛出错误。

Async/await 的错误处理有哪些最佳实践？

Async/await 的错误处理主要依赖 try...catch 块。以下是一些最佳实践：

1. 包裹每个 await 表达式： 确保每个 await 表达式都在 try...catch 块中，这样可以捕获该异步操作可能抛出的任何错误。
2. 集中式错误处理： 在 async 函数的顶层使用一个 try...catch 块，可以捕获函数内部所有 await 表达式可能抛出的错误。
3. 重新抛出错误： 在 catch 块中，可以选择处理错误，或者重新抛出错误，让调用者处理。如果选择重新抛出错误，应该使用 throw error 而不是 throw new Error(error.message)，这样可以保留原始的错误堆栈信息。
4. 使用自定义错误类： 可以定义自定义的错误类，用于区分不同类型的错误，方便进行更精细的错误处理。

class CustomError extends Error {
  constructor(message, code) {
    super(message);
    this.name = 'CustomError';
    this.code = code;
  }
}

async function processData() {
  try {
    const data = await fetchData();
    if (!data) {
      throw new CustomError('Data is empty', 404);
    }
    // ... process data ...
  } catch (error) {
    if (error instanceof CustomError) {
      console.error('Custom error:', error.message, error.code);
    } else {
      console.error('Unexpected error:', error);
    }
  }
}

如何在循环中使用 Async/await？

在循环中使用 async/await 需要特别注意，因为如果直接在循环中使用 await，会导致循环变成串行执行，效率很低。

串行执行（不推荐）：

async function processItems(items) {
  for (const item of items) {
    const result = await processItem(item); // 串行执行
    console.log('Result:', result);
  }
}

并行执行（推荐）：

可以使用 Promise.all() 来并行执行循环中的异步操作。

async function processItems(items) {
  try {
    const results = await Promise.all(items.map(async item => {
      return await processItem(item); // 并行执行
    }));
    console.log('Results:', results);
    return results;
  } catch (error) {
    console.error('Error processing items:', error);
    throw error;
  }
}

这个例子中，items.map(async item => await processItem(item)) 会创建一个 Promise 数组，每个 Promise 对应一个 processItem 的异步操作。Promise.all() 会并发执行这些 Promise，并在所有 Promise 都 resolve 后返回一个包含所有结果的数组。

Async/await 的性能考量

虽然 async/await 提高了代码的可读性，但在某些情况下可能会影响性能。

1. 额外的 Promise 对象： Async 函数会返回一个 Promise 对象，这会带来一些额外的开销。
2. 微任务队列： Async/await 基于微任务队列，可能会导致一些延迟。
3. 过度使用： 不恰当的使用 async/await 可能会导致代码执行效率降低。

在性能敏感的场景中，需要仔细评估 async/await 的使用，并考虑是否可以使用其他优化方法，例如：

• 避免不必要的 async 函数。
• 使用 Web Workers 或其他并发技术。
• 优化 Promise 的创建和解析。

总的来说，async/await 是一种强大的工具，可以简化异步代码的编写和维护。但需要理解其底层原理，并根据实际情况进行合理使用，才能充分发挥其优势。

到这里，我们也就讲完了《async和await入门教程详解》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于异步操作,Promise,try...catch,async/await,Promise.all()的知识点！