promise-如何使异步代码在没有async/Await的情况下同步执行？

Question

  var p1 = new Promise(function(resolve, reject) {  
    setTimeout(() => resolve("first"), 5000);
  });
  var p2 = new Promise(function(resolve, reject) {  
    setTimeout(() => resolve("second"), 2000);
  });
  var p3 = new Promise(function(resolve, reject) {  
    setTimeout(() => resolve("third"), 1000);
  });

  console.log("last to print");

p1.then(()=>p2).then(()=>p3).then(()=> console.log("last to be printed"))

当我在阅读有关承诺的文章时，我知道当我使用async/Await时，我可以同步打印承诺（在本例中为print：first,second,third,last to print）。现在我也读到了使用链接和异步/等待也可以达到同样的目的。然而，当我试图将我的承诺链接起来时，除了“最后一次打印”的console.log之外，什么也没有发生。任何洞察力都会很棒！谢谢！！

编辑到问题：

  var p1 = new Promise(function (resolve, reject) {
    setTimeout(() => console.log("first"), 5000);
    resolve("first resolved")
  });
  var p2 = new Promise(function (resolve, reject) {
    setTimeout(() => console.log("second"), 2000);
    resolve("second resolved")
  });
  var p3 = new Promise(function (resolve, reject) {
    setTimeout(() => console.log("third"), 0);
    resolve("third resolved")
  });

  console.log("starting");
  p1.then((val) => {
    console.log("(1)", val)
    return p2
  }).then((val) => {
    console.log("(2)", val)
    return p3
  }).then((val) => {
    console.log("(3)", val)
  })

日志：

starting
(1) first resolved
(2) second resolved
(3) third resolved
third
second
first

1：如果传递给new Promise的executor函数在返回new Promise之前被立即执行，那么为什么在setTimeouts（异步）被执行之后，这里的Promissions resolved（）synchronouts（）？

返回值与解析承诺：

var sync=function（）{return new Promise（function（resolve,reject）{setTimeout（（）=>{console.log（“start”）resolve（“hello”）//---工作//return“hello”//-->不做任何事情},3000）；}）}sync（）.then（（val）=>console.log（“val”,val））

Answer 1

无法使异步代码同步执行。

即使async/await也只是一种语法，它在Promise中为您提供了一个同步样式的控制流。

然而，当我试图将我的承诺链接起来时，除了“最后一次打印”的console.log之外，什么也没有发生。任何洞察力都会很棒！

其他函数不生成任何输出。这与他们的承诺无关。

你开始三个计时器（所有的时间），然后记录“最后打印”，然后链接一些承诺，使“最后打印”将打印时，所有三个承诺解决（5秒后，你开始他们所有）。

如果您希望计时器按顺序运行，那么您必须在前一个计时器完成时才启动它们，如果您想查看它们的解析结果，那么您必须编写实际查看该结果的代码。

null

function p1() {
  return new Promise(function(resolve, reject) {
    setTimeout(() => resolve("first"), 5000);
  });
}

function p2() {
  return new Promise(function(resolve, reject) {
    setTimeout(() => resolve("second"), 2000);
  });
}

function p3() {
  return new Promise(function(resolve, reject) {
    setTimeout(() => resolve("third"), 1000);
  });
}

function log(value) {
  console.log("Previous promise resolved with " + value);
}

p1()
  .then(log)
  .then(p2)
  .then(log)
  .then(p3)
  .then(log)
  .then(() => console.log("last to be printed"));

Answer 2

您传递给new promise的executor函数将在返回新promise之前立即执行。因此，当您这样做时：

var p1 = new Promise(function(resolve, reject) {  
  setTimeout(() => resolve("first"), 5000);
});

...在将承诺分配给P1时，SetTimeout已被调用，并在五秒后安排回调。无论您是否监听promise的解决方案，都会发生回调，无论您是通过await关键字还是通过then方法监听解决方案，都会发生回调。

因此，您的代码立即启动三个settimeouts，然后开始等待第一个承诺的解决方案，然后只等待第二个承诺的解决方案（它已经解决了，所以这几乎是立即的），然后等待第三个承诺的解决方案（同样）。

若要使您的代码仅在前一个超时完成时依次执行那些settimeout调用，则必须在前一个承诺解决之前（使用较短的超时以避免大量等待）不创建新承诺：

null

console.log("starting");
new Promise(function(resolve, reject) {  
  setTimeout(() => resolve("first"), 1000);
})
.then(result => {
    console.log("(1) got " + result);
    return new Promise(function(resolve, reject) {  
      setTimeout(() => resolve("second"), 500);
    });
})
.then(result => {
    console.log("(2) got " + result);
    return new Promise(function(resolve, reject) {  
      setTimeout(() => resolve("third"), 100);
    });
})
.then(result => {
    console.log("(3) got " + result);
    console.log("last to print");
});