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));
在这个例子中：
- async function fetchData() 定义了一个异步函数。
- await fetch(‘https://api.example.com/data’) 暂停函数执行，直到 fetch 返回的 Promise resolve。
- await response.json() 同样暂停函数执行，直到 response.json() 返回的 Promise resolve。
- 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 块。以下是一些最佳实践：
- 包裹每个 await 表达式： 确保每个 await 表达式都在 try…catch 块中，这样可以捕获该异步操作可能抛出的任何错误。
- 集中式错误处理： 在 async 函数的顶层使用一个 try…catch 块，可以捕获函数内部所有 await 表达式可能抛出的错误。
- 重新抛出错误： 在 catch 块中，可以选择处理错误，或者重新抛出错误，让调用者处理。如果选择重新抛出错误，应该使用 throw error 而不是 throw new Error(error.message)，这样可以保留原始的错误堆栈信息。
- 使用自定义错误类： 可以定义自定义的错误类，用于区分不同类型的错误，方便进行更精细的错误处理。
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 提高了代码的可读性，但在某些情况下可能会影响性能。
- 额外的 Promise 对象： Async 函数会返回一个 Promise 对象，这会带来一些额外的开销。
- 微任务队列： Async/await 基于微任务队列，可能会导致一些延迟。
- 过度使用： 不恰当的使用 async/await 可能会导致代码执行效率降低。
在性能敏感的场景中，需要仔细评估 async/await 的使用，并考虑是否可以使用其他优化方法，例如：
- 避免不必要的 async 函数。
- 使用 Web Workers 或其他并发技术。
- 优化 Promise 的创建和解析。
总的来说，async/await 是一种强大的工具，可以简化异步代码的编写和维护。但需要理解其底层原理，并根据实际情况进行合理使用，才能充分发挥其优势。
