javascript - 为什么Promise和async/await以不同的顺序解析Promise？

从我阅读的所有内容来看，异步/等待只是诺言的句法糖。因此，假设promise_1和promise_2都是应许的，我希望以下两个功能可以相同地工作：

function promises(promise_1, promise_2) {
    promise_1.then((val) => {
        console.log(val);
        promise_2.then((val2) => {
            console.log(val2);
        });
    });
}
async function asyncawait(promise_1, promise_2) {
    console.log(await promise_1);
    console.log(await promise_2);
}

但是，在测试它们时，我注意到promises函数比异步函数更早地解决了第二个承诺：

let func;
async function test() {
    let promise_1 = Promise.resolve("first");
    let promise_2 = Promise.resolve("second");

    func(promise_1, promise_2);

    console.log("await first");
    await promise_1;
    console.log("awaited first");

    console.log("await second");
    await promise_2
    console.log("awaited second");
}

跑步

func = promises;
test();

产生以下输出：

await first
first
second
awaited first
await second
awaited second

请注意在等待promise_1之后，promise_1和promise_2都如何解析。

但是，跑步

func = asyncawait;
test();

产生以下（预期）输出：

await first
first
awaited first
await second
second
awaited second

与承诺的决议交织在一起。

是什么引起这种分辨率顺序上的差异？

最佳答案

是的，正如您正确地说过的那样：“异步/等待只是诺言的语法糖”。考虑一下

function foo(flag){
  return new Promise((res, rej) => {
    setTimeout(() => {
      if(flag) res("Resolved");
      else rej("Rejected")
    },1000);
  })
}

这里的关键是异步函数总是返回promise。见return value of a async function

现在，让我们使用此功能

function useFoo(){
  return foo(true).then(val => { console.log(val); return val; })
                  .catch(err => { console.log(err); throw err; })
}

这相当于

async function useFoo(){
  try{
    const val = await foo(false);
    console.log(val);
    return val;
  }catch(err){
    console.log(err);
    throw err;
  }
}

解释您的行为，

(function(){
  foo(1).then((x)=> console.log(x));
  console.log("after foo()");
})()

使用相同的foo函数，由于foo（）是异步函数，因此上述代码段先记录after foo()。对于执行程序函数的同步操作，将立即执行。

这就是“异步/等待只是诺言的语法糖”的方式

关于javascript - 为什么Promise和async/await以不同的顺序解析Promise？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/57799289/