J*aScript async/await 异步执行序列问题详解_石家庄创泽智能科技有限公司

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

J*aScript async/await 异步执行序列问题详解

2025-11-30

浏览次数：次

返回列表

javascript async/await 异步执行序列问题详解

本文深入探讨了J*aScript中`async/await`语句在处理异步操作时可能遇到的执行序列不一致问题。通过分析一个常见案例，揭示了`await`语句必须等待一个Promise才能正确暂停执行的机制。文章详细介绍了如何通过将函数声明为`async`并确保其返回内部的Promise来解决此类问题，最终实现预期的异步代码执行顺序，并提供了最佳实践。

引言：理解 J*aScript 中的 async/await

在现代J*aScript开发中，处理异步操作是不可避免的。async/await 是ES2017引入的语法糖，旨在使异步代码的编写和阅读更加直观，使其看起来更像同步代码，从而避免回调地狱。

async 关键字：用于声明一个函数为异步函数。一个async函数总是返回一个Promise。如果函数内部没有显式返回Promise，它会隐式地返回一个已解决的Promise，其值为函数的返回值。
await 关键字：只能在 async 函数内部使用。它会暂停 async 函数的执行，直到其后的 Promise 解决（fulfilled）或拒绝（rejected）。一旦Promise解决，await表达式会返回Promise的解决值；如果Promise被拒绝，await会抛出错误。

正确理解这两个关键字的工作原理对于编写可预测的异步代码至关重要。

问题剖析：await 行为不一致的原因

考虑以下代码片段，其目标是按顺序输出 1、3、2：

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 -> reloadScenarios 内部的异步操作完成（console.log("3")） -> 2。然而，实际的输出顺序却是 1 -> 2 -> 3。

原因分析：

核心问题在于 await reloadScenarios(); 这一行。await 关键字的作用是等待一个 Promise 解决。然而，在原始的 reloadScenarios 函数中：

它不是一个 async 函数：因此，它不会隐式地返回一个 Promise。
它没有显式地返回一个 Promise：getScenario().then(...) 确实返回了一个 Promise，但这个 Promise 并没有从 reloadScenarios 函数中返回出去。
函数立即返回 undefined：当 reloadScenarios 被调用时，它会立即执行其中的同步代码（if (token)），然后发起异步的 getScenario() 调用，但函数本身并没有等待这个异步调用完成就直接返回了。由于没有显式的 return 语句，它默认返回 undefined。

因此，await reloadScenarios() 实际上等同于 await undefined。由于 undefined 不是一个 Promise，J*aScript 引擎会立即将其视为一个已解决的值，然后继续执行 console.log("2")，导致 2 在 3 之前输出。

解决方案一：将函数声明为 async

解决此问题的首要步骤是将 reloadScenarios 函数声明为 async。

console.log("1");
await reloadScenarios();
console.log("2");

const reloadScenarios = async () => { // 添加 async 关键字
    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);
            });
    }
};

通过添加 async 关键字，reloadScenarios 函数现在会返回一个 Promise。当 await reloadScenarios() 被调用时，它会等待这个由 reloadScenarios 返回的 Promise 解决。

然而，仅仅将函数声明为 async 可能还不足以完全解决问题。虽然 async 函数本身会返回一个 Promise，但如果其内部的异步操作（如 getScenario()）没有被正确地 await 或 return 出去，那么外部的 await 可能会在内部的异步操作完成之前就解决。在这种情况下，await reloadScenarios() 仍然可能在 console.log("3") 之前让出控制权给 console.log("2")。

解决方案二：确保 async 函数返回其内部的 Promise

为了确保 await reloadScenarios() 能够真正等待到 getScenario() 及其 .then() 回调中的所有操作完成，async 函数内部必须显式地 return 其包含的 Promise 链。

Pinokio

Pinokio是一款开源的AI浏览器，可以安装运行各种AI模型和应用

232 查看详情 Pinokio

console.log("1");
await reloadScenarios();
console.log("2");

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);
                // 捕获错误后，可以重新抛出或返回一个被拒绝的Promise
                throw error; // 或者 return Promise.reject(error);
            });
    }
    // 如果 token 不存在，也需要返回一个 Promise，例如一个已解决的Promise
    return Promise.resolve();
};

最终的执行流程：

console.log("1"); 输出 1。
await reloadScenarios(); 被调用。
reloadScenarios 函数被执行。
如果 token 存在，getScenario() 被调用，并返回一个 Promise。
这个 Promise 链（getScenario().then(...).catch(...)）被 reloadScenarios 函数 return 出去。
由于 reloadScenarios 是 async 函数，它返回的 Promise 现在是这个内部 Promise 链的封装。
await 关键字会暂停外部函数的执行，直到 reloadScenarios 返回的 Promise 解决（即 getScenario().then(...) 中的所有操作完成，包括 console.log("3")）。
一旦 getScenario().then(...) 完成并解决，await reloadScenarios() 也会解决。
console.log("2"); 输出 2。

通过这种方式，执行顺序将变为预期的 1 -> 3 -> 2。

最佳实践与注意事项

为了充分利用 async/await 的优势并避免常见的陷阱，请遵循以下最佳实践：

await 只能等待 Promise：始终确保 await 后面跟着一个 Promise。如果它后面不是 Promise，J*aScript 会立即将其视为一个已解决的值。
await 必须在 async 函数中使用：这是语法规定。如果你想在顶层模块中使用 await，需要确保你的环境支持顶层 await (Top-level await)，或者将其封装在一个 async IIFE (Immediately Invoked Function Expression) 中。

错误处理：在 async/await 中，可以使用传统的 try...catch 语句来捕获 Promise 拒绝（错误）。

const fetchData = async () => {
    try {
        const data = await getScenario();
        console.log("数据获取成功:", data);
    } catch (error) {
        console.error("数据获取失败:", error);
    }
};

明确返回 Promise：如果一个 async 函数内部执行了异步操作，并且你希望外部的 await 能够等待这些操作完成，那么请确保从 async 函数中 return 那些异步操作的 Promise。
避免混合使用 then/catch 和 async/await：虽然技术上可行，但过度混合可能导致代码难以阅读和维护。尽可能地使用 await 来替代 .then()，并使用 try...catch 替代 .catch()。
并行执行：如果你需要并行执行多个异步操作而不是串行等待，可以使用 Promise.all() 结合 await。
```
const [result1, result2] = await Promise.all([
    asyncOperation1(),
    asyncOperation2()
]);
```