本文深入探讨 javascript 中 `async/await` 的正确使用方式，以解决异步操作执行顺序不一致的问题。我们将通过一个具体的代码案例，分析 `await` 关键字在等待非 promise 值时的行为，并详细阐述如何通过将函数声明为 `async` 以及确保其返回 promise 来有效控制异步代码的执行流程，从而实现预期的顺序。
在现代 JavaScript 开发中，async/await 已经成为处理异步操作的首选方式，它以同步的写法来表达异步逻辑，极大地提升了代码的可读性和可维护性。然而，如果不完全理解其底层机制，可能会遇到意料之外的执行顺序问题。本文将通过一个实际案例，深入剖析 await 的工作原理，并提供确保异步代码按预期执行的正确方法。
问题场景：await 关键字的误解
考虑以下 JavaScript 代码片段，它旨在加载场景数据并更新 UI：
console.log("1");
await reloadScenarios();
console.log("2");
const reloadScenarios = () => {
if (token) {
getScenario()
.then(({ scenarios }) => {
console.log("3");
const transformedScenarios = scenarios.map(option => ({
scenario: option.name,
description: option.categories.name,
value: option._id
}));
setOptions(transformedScenarios);
})
.catch((error) => {
console.error('Failed to fetch scenario options:', error);
});
}
};开发者期望的执行顺序是 1 -> 3 -> 2。然而，实际运行时，控制台输出的顺序却是 1 -> 2 -> 3。这种不一致的执行顺序表明 await reloadScenarios() 并没有按照预期暂停代码执行，直到 getScenario() 完成。
await 的工作原理：等待 Promise
await 关键字的本质是等待一个 Promise 对象的解决（resolved）或拒绝（rejected）。当 await 后面跟着一个 Promise 时，它会暂停当前 async 函数的执行，直到该 Promise 状态确定。一旦 Promise 解决，await 表达式会返回 Promise 的解决值；如果 Promise 被拒绝，await 会抛出拒绝的原因。
立即学习“Java免费学习笔记（深入）”；
关键点在于：await 只能真正“等待” Promise。 如果 await 后面跟着的表达式不是一个 Promise（例如，它是一个普通值、undefined 或一个同步函数），那么 await 表达式会立即解析为该值，不会暂停执行。
在上述问题代码中，reloadScenarios 函数是一个普通的同步函数，它没有被 async 关键字修饰，也没有显式地返回一个 Promise。当 await reloadScenarios() 被调用时，reloadScenarios() 函数会同步执行，它会启动 getScenario() 这个异步操作（返回一个 Promise），但 reloadScenarios() 函数本身会立即返回 undefined。因此，await undefined 会立即解析，导致 console.log("2") 在 getScenario() 的 .then() 回调（包含 console.log("3")）之前执行。
解决方案：正确使用 async 函数和 Promise 返回
要实现期望的 1 -> 3 -> 2 执行顺序，我们需要确保 await reloadScenarios() 确实能够等待内部的异步操作完成。这需要对 reloadScenarios 函数进行两方面的调整：
1. 将函数声明为 async
使用 async 关键字修饰函数，使其成为一个异步函数。async 函数总是返回一个 Promise。
const reloadScenarios = async () => { // 关键：添加 async 关键字
// ... 函数体
};当一个函数被标记为 async 后，即使它没有显式地返回 Promise，它也会隐式地返回一个 Promise。这个 Promise 会在函数执行完毕时解决，或者在函数内部遇到 await 表达式时暂停，等待被 await 的 Promise 解决。
2. 确保 async 函数返回或 await 内部的 Promise
仅仅将函数标记为 async 并不足以解决所有问题。我们还需要确保 async 函数内部的异步操作能够被外部的 await 链正确捕获。这可以通过两种方式实现：
方法一：显式返回 Promise 链
让 async 函数显式地返回内部的 Promise 链。
const reloadScenarios = async () => {
if (token) {
// 关键：返回 getScenario() 返回的 Promise 链
return getScenario()
.then(({ scenarios }) => {
console.log("3");
const transformedScenarios = scenarios.map(option => ({
scenario: option.name,
description: option.categories.name,
value: option._id
}));
setOptions(transformedScenarios);
})
.catch((error) => {
console.error('Failed to fetch scenario options:', error);
// 错误处理，如果希望外部 await 也能捕获，需要 re-throw
throw error;
});
}
// 如果 token 不存在，也需要返回一个 resolved 的 Promise，
// 否则外部 await 会立即解析为 undefined
return Promise.resolve();
};在这种情况下，await reloadScenarios() 会等待 reloadScenarios 返回的 Promise 解决，而 reloadScenarios 返回的 Promise 又会等待 getScenario().then(...) 解决。
方法二（推荐）：在 async 函数内部使用 await
这是更符合 async/await 语义的写法，它使得异步代码看起来更像同步代码。
const reloadScenarios = async () => { // 关键：添加 async 关键字
if (token) {
try {
// 关键：在 async 函数内部 await getScenario()
const { scenarios } = await getScenario();
console.log("3");
const transformedScenarios = scenarios.map(option => ({
scenario: option.name,
description: option.categories.name,
value: option._id
}));
setOptions(transformedScenarios);
} catch (error) {
console.error('Failed to fetch scenario options:', error);
// 抛出错误，以便外部 await 也能捕获
throw error;
}
}
};采用此方法后，完整的代码将是：
console.log("1");
await reloadScenarios(); // 现在会等待 reloadScenarios 内部的 await 完成
console.log("2");
const reloadScenarios = async () => { // 1. 标记为 async
if (token) {
try {
const { scenarios } = await getScenario(); // 2. 内部 await
console.log("3");
const transformedScenarios = scenarios.map(option => ({
scenario: option.name,
description: option.categories.name,
value: option._id
}));
setOptions(transformedScenarios);
} catch (error) {
console.error('Failed to fetch scenario options:', error);
// 重要的错误传播：如果希望外部的 await 能捕获到错误，需要重新抛出
throw error;
}
}
};
// 假设 getScenario 和 token 已经定义
// const getScenario = () => new Promise(resolve => setTimeout(() => resolve({ scenarios: [{ name: 'S1', categories: { name: 'C1' }, _id: 'id1' }] }), 100));
// const setOptions = (opts) => console.log('Set options:', opts);
// const token = true;现在，执行顺序将是 1 -> 3 -> 2，符合预期。await reloadScenarios() 会等待 reloadScenarios 内部的 await getScenario() 完成，包括其 .then() 回调中的 console.log("3")。
总结与注意事项
- async 函数总是返回 Promise：无论 async 函数内部返回什么值，它都会被包裹在一个 Promise 中。如果函数没有显式返回，它会隐式返回 Promise.resolve(undefined)。
- await 只能等待 Promise：await 关键字的真正作用是等待一个 Promise 解决。如果它等待的不是 Promise，它会立即解析，不会暂停执行。
- 内部 await 的重要性：在 async 函数内部，如果你想等待另一个异步操作完成，务必使用 await。否则，该异步操作将并行执行，并且 async 函数可能会在它完成之前就返回。
- 错误处理：在 async/await 中，使用 try...catch 块来处理 Promise 的拒绝（rejected）状态。如果希望错误能向上层 await 调用者传播，记得在 catch 块中 throw error。
正确理解和运用 async/await 的这些核心概念，是编写健壮、可读性强的异步 JavaScript 代码的关键。通过确保 async 函数正确返回或 await 内部的 Promise，我们可以有效地控制异步操作的执行流程，避免意外的执行顺序问题。
