Javascript 为什么承诺和异步/等待以不同的顺序解析承诺？

从我所读到的所有内容来看，async/await只是承诺的语法糖。因此，假设

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

函数比异步函数更早解析第二个promise：

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\u 1

后，

promise\u 1

和

promise\u 2

如何解决

然而，运行

func = asyncawait;
test();

生成以下（预期）输出：

与承诺决议交织在一起

---

<> P>是的，正如你正确地指出的：“Asic/aAcess只是承诺的语法糖”。

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

这里的关键是异步函数总是返回一个承诺。看

现在，让我们使用这个函数

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函数，上面的代码片段在foo（）之后记录

。对于executor函数的同步操作，将立即执行

---

<>这就是“Asic/Acess只是承诺的句法糖”< /P> < P>是的，正如你正确地指出的：“Assic/Acess只是承诺的语法糖”。

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

这里的关键是异步函数总是返回一个承诺。看

现在，让我们使用这个函数

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函数，上面的代码片段在foo（）之后记录

。对于executor函数的同步操作，将立即执行

---

这就是为什么在chrome 76.0.3809.100中“async/await只是承诺的语法糖”

这两个函数产生相同的输出。这个测试毫无意义，两个承诺在等待之前就已经解决了，这是一个等待将更快完成的比赛条件。为什么你希望其中一个等待解锁另一个呢？不能重编：有趣的是，这在我的节点测试环境和firefox中都是一致的。我猜这只是浏览器的怪异。第二个行为是预期的，因为尽管它们都已解决，但一旦test（）返回，只有第一个承诺附加了then（）处理程序。我希望在创建任何新的then（）解析之前解决这两个问题（例如，使用FIFO队列进行解析）。您是否使用Babel、TypeScript或其他代码传输工具？生成的代码似乎不正确。是的，对Node使用TypeScript，但我直接在Firefox控制台中获得这种行为，因此没有传输。在chrome 76.0.3809.100中，两个函数都产生相同的输出。这个测试毫无意义，两个承诺在等待之前就已经解决了，这是一个等待将更快完成的比赛条件。为什么你希望其中一个等待解锁另一个呢？不能重编：有趣的是，这在我的节点测试环境和firefox中都是一致的。我猜这只是浏览器的怪异。第二个行为是预期的，因为尽管它们都已解决，但一旦test（）返回，只有第一个承诺附加了then（）处理程序。我希望在创建任何新的then（）解析之前解决这两个问题（例如，使用FIFO队列进行解析）。您是否使用Babel、TypeScript或其他代码传输工具？生成的代码似乎不正确。是的，对节点使用TypeScript，但我直接在Firefox控制台中获得此行为，因此没有传输。抱歉，但我不明白这是如何解释我的行为的。我的测试函数本身被标记为异步，after print语句就在await语句之后。@fuzzything 44最后一段解释了第一个测试的行为，即test=promises，第一个打印在第一个promise的.then（）中，第二个打印在第二个promise的.then（）中。您的示例在添加.then（）处理程序后进行了打印，但在该处理程序之外。这不能解释第一次测试。对不起，我不明白这是怎么解释我的行为的。我的测试函数本身被标记为异步，after print语句就在await语句之后。@fuzzything 44最后一段解释了第一个测试的行为，即test=promises，第一个打印在第一个promise的.then（）中，第二个打印在第二个promise的.then（）中。您的示例在添加.then（）处理程序后进行了打印，但在该处理程序之外。这并不能解释第一次测试。