如果您的唯一目标是为了测试目的控制混合了其他代码的异步代码的执行顺序，那么您可以将整个顶级代码包装在定义为异步函数的立即调用函数表达式(IIFE)中。在问题的示例中，在调用main()之前添加await。

当您的代码不在异步函数中或不在模块的顶层主体中时，可以使用此模式。换句话说，如果你只是在一个js文件中测试一堆代码，并使用Live Server、RunJs或任何其他类型的JavaScript工具来观察控制台窗口，将所有代码包装在定义为异步的IIFE中，当你想在执行下一行之前等待异步代码完成时，使用await关键字。

let topLevelIIFE = (async () => { 异步函数main() { var value = await承诺。解决('嘿'); Console.log ('inside: ' + value); 返回值; ｝ Var文本=等待main(); Console.log ('outside: ' + text); }) ()

在Chrome DevTools或其他行为类似的浏览器REPL工具的REPL中运行IIFE主体中指定的代码时，您不需要使用此模式。

我喜欢这种聪明的语法来从入口点执行异步工作

void async function main() {
  await doSomeWork()
  await doMoreWork()
}()

因为main()是异步运行的，所以它返回一个承诺。你必须在then()方法中获取结果。因为then()也返回promise，所以必须调用process.exit()来结束程序。

main()
   .then(
      (text) => { console.log('outside: ' + text) },
      (err)  => { console.log(err) }
   )
   .then(() => { process.exit() } )

其他解决方案缺乏POSIX兼容性的一些重要细节:

你需要…

成功时报告0退出状态，失败时报告非0退出状态。 向标准输出流发出错误。

#!/usr/bin/env node

async function main() {
 // ... await stuff ... 
}

// POSIX compliant apps should report an exit status
main()
    .then(() => {
        process.exit(0);
    })
    .catch(err => {
        console.error(err); // Writes to stderr
        process.exit(1);
    });

如果使用command等命令行解析器，则可能不需要main()。

例子:

#!/usr/bin/env node

import commander from 'commander'

const program = new commander.Command();

program
  .version("0.0.1")
  .command("some-cmd")
  .arguments("<my-arg1>")
  .action(async (arg1: string) => {
    // run some async action
  });

program.parseAsync(process.argv)
  .then(() => {
    process.exit(0)
  })
  .catch(err => {
    console.error(err.message || err);
    if (err.stack) console.error(err.stack);
    process.exit(1);
  });

我不明白为什么这行不通。

因为主回承诺;所有异步函数都是这样。

在顶层，你必须:

使用顶级等待(提案，MDN;ES2022，在现代环境中广泛支持)，允许在模块中顶级使用await。 或 使用从不拒绝的顶级异步函数(除非你想要“未处理的拒绝”错误)。 或 使用then和catch。

模块中的#1顶级await

您可以在模块的顶层使用await。你的模块不会完成加载，直到你等待的承诺解决(意味着任何模块等待你的模块加载不会完成加载，直到承诺解决)。如果承诺被拒绝，您的模块将无法加载。通常，顶级await用于这样的情况:你的模块在承诺被解决之前无法完成它的工作，除非承诺被实现，否则根本无法完成它，所以这很好:

const text = await main();
console.log(text);

如果你的模块可以在promise被拒绝的情况下继续工作，你可以在try/catch中包装顶层的await:

// In a module, once the top-level `await` proposal lands
try {
    const text = await main();
    console.log(text);
} catch (e) {
    // Deal with the fact the chain failed
}
// `text` is not available here

当一个使用顶级await的模块被求值时，它会向模块加载器返回一个promise(就像async函数一样)，加载器会一直等待，直到这个promise被确定，然后再计算依赖它的任何模块的主体。

你不能在非模块脚本的顶层使用await，只能在模块中使用。

#2 -从不拒绝的顶级异步函数

(async () => {
    try {
        const text = await main();
        console.log(text);
    } catch (e) {
        // Deal with the fact the chain failed
    }
    // `text` is not available here
})();
// `text` is not available here, either, and code here is reached before the promise settles
// and before the code after `await` in the main function above runs

注意其中的陷阱;你必须处理承诺拒绝/异步异常，因为没有其他事情要做;你没有调用者来传递它们(不像上面的#1，你的“调用者”是模块加载器)。如果你愿意，你可以通过catch函数调用它的结果(而不是try/catch语法):

(async () => {
    const text = await main();
    console.log(text);
})().catch(e => {
    // Deal with the fact the chain failed
});
// `text` is not available here, and code here is reached before the promise settles
// and before the code after `await` in the main function above runs

.．.它更简洁一些，尽管它在某种程度上混合了模型(async/await和显式promise回调)，否则我通常建议不要这样做。

当然，也可以不处理错误，只允许出现“未处理的拒绝”错误。

#3 -然后抓住

main()
    .then(text => {
        console.log(text);
    })
    .catch(err => {
        // Deal with the fact the chain failed
    });
// `text` is not available here, and code here is reached before the promise settles
// and the handlers above run

如果链中或then处理程序中发生错误，将调用catch处理程序。(请确保您的catch处理程序不会抛出错误，因为没有注册任何东西来处理它们。)

或者两个论证都是:

main().then(
    text => {
        console.log(text);
    },
    err => {
        // Deal with the fact the chain failed
    }
);
// `text` is not available here, and code here is reached before the promise settles
// and the handlers above run

再次注意，我们注册了一个拒绝处理程序。但是在这种形式中，请确保您的then回调都不会抛出任何错误，因为没有注册任何东西来处理它们。

在NodeJS 14.8+中，你可以使用顶级的await模块(#3解决方案)。你也可以将.js重命名为.mjs (ES模块)而不是.js(。cj CommonJS)。