如何同步 Promise 对象？

Question

我有需要同步工作的承诺对象。例如，在第一个承诺完成之前，第二个承诺不应该起作用。如果第一个拒绝第一个必须再次执行。

我已经实现了一些示例。这个效果很好。 调用getVal，等待2000ms，返回，i++，再次调用getVal.....

 getVal() {
       return new Promise(function(resolve, reject) {
      setTimeout(function(){ resolve(19) }, 2000);
         });

     }

async promiseController(){

    for(var i =0;i<5;i++)
      {
        var _val = await this.getVal()
        console.log(_val+'prom');
      }
    }

但我需要控制一组 promise 对象。我想要做的是我有一个数据，我把它分成了5块。处理好第一部分（例如：发送到服务器）后，我想处理第二部分，否则我必须再次处理第一部分。

这是我做的原型实现

  getVal() {
   return new Promise(function(resolve, reject) {
  setTimeout(function(){ resolve(19) }, 2000);
     });

 }

async promiseController(){
  var proms=[]
  for(var i =0;i<5;i++)
    {
      proms.push(this.getVal())
    }

for(var i =0;i<5;i++)
  {
    var _val = await proms[i]
    console.log(_val+'prom');
  }
}

此代码中的 Promises 对象按顺序工作。如何修复下面的代码，使其作为第一个示例同步工作。

Answer 1

async promiseController(){
  for(const value of array) {
    console.log((await this.getVal(value))+'prom');
  }
}

无需使事情过于复杂。只需在循环内调用await，它就会等待你想要的。

正如另一个答案正确地说 - 一个承诺代表一个价值，而不是一个操作。对于操作，使用常规函数。

如果你想忽略失败，你可以.catch(() => {}) 承诺。如果您想重试直到失败 - 您可以将重试重构为一个函数并使用它：

const retry = fn => (...args) => fn(...args).catch(retry(fn));

Answer 2

如果您的目标是在第一个 Promise 解决之前不“执行后续的 Promise”，那么您需要记住，Promise 代表异步活动已经在进行中。一旦承诺存在，就为时已晚。

您需要在第一个 Promise 完成之前不要调用后续的 Promise 工厂方法。您的第一个示例通过在前一个承诺完成之前不调用 getVal() 来做到这一点。

所以你最终会得到类似的东西：

delay(time) {
    return new Promise(resolve => setTimeout(resolve, time));
}

async promiseController() {
    const factories = [];
    for (let i = 0; i < 5; ++i) {
        factories.push(() => this.getVal());
    }

    for (const f of factories) {
        // keep running this factory until it succeeds
        let success = false;
        while (!success) {
            try {
                const promise = f();
                const result = await f;
                success = true;
                console.log(`result = ${result}`);
            }
            catch (err) {
                console.log("promise failed.  retrying");
                await delay(100);
            }
        }
    }
}

Answer 3

可以使用递归，命名函数，.then()

var arr = [Promise.resolve("a")
           , Promise.resolve("b")
           , Promise.resolve("c")];
var i = 0;
var res = [];

function foo() {
  // conditional resolved or rejected promise
  var n = String(new Date().getTime()).slice(-1);
  // if `n` < 5 reject `n` , else resolve `n`
  var curr = n < 5;
  return curr ? arr[i] : Promise.reject(["rejected", n])
}

var p = (function repeat() {
  var promise = foo();
  return promise
    .then(function(data) {
      console.log(data);
      res.push(data);
      ++i;
      if (i < arr.length) return repeat()
      // return `res` array when all promises complete
      else return res
    })
    .catch(function(err) {
      console.log(err);
      if (err[0] === "rejected") return repeat()
    })
}());

p.then(function(complete) {
  console.log("complete:", complete)
});

Answer 4

好吧。我相信为了正确的函数式编程目的，应该避免使用async 和await。我相信承诺是非常充分的。但是，如果您想继续以 C++ 类似的命令式风格进行编码，那么 async 和 await 适合您。

我有需要同步工作的承诺对象。例如 在第一个承诺完成之前，第二个承诺不应该起作用。如果第一个 拒绝第一个必须再次执行。

让我简要介绍一下下面的代码。我们有 async() 函数，它接受数据和回调（错误第一类型）。至于演示目的，它将尝试在 2000 毫秒内使用数据调用回调，但是在 1000 毫秒时会出现超时。所以 50-50 它将调用带有数据或错误的回调。

所以我们实际上需要它来向我们返回一个承诺，所以我在 promisify() 的帮助下承诺它，它需要 async() 函数并返回 asyncPro() 函数。这实际上与async() 相同，但返回的是一个承诺。所以我们应该在then 阶段使用我们的回调。

然后是tryNTimes(data,asyncFun,n = 5) 函数，它接收数据、一个承诺的异步函数和一个整数，指定在拒绝之前尝试的次数。默认尝试计数为 5，但您可以通过传递第三个参数将其设置为任何值。

至于最后一部分，我们有flowControl()，它在Array.prototype.reduce() 的帮助下完美地链接了我们的承诺。

所以现在我们将所有的承诺一个接一个地链接起来，在尝试 5 次之前没有一个会失败。

function promisify(fun){
  return (data) => new Promise((resolve,reject) => fun(data, (err,res) => err ? reject(err) : resolve(res)));
}

function async(data, callback){
  var dur = Math.floor(Math.random()*2000);
  setTimeout(_ => callback(false,data),dur);           // may resolve before timeout
  setTimeout(_ => callback("error at " + data),1000);  // timeout at 1 sec
}

function tryNTimes(data,asyncFun,n = 5){
  return new Promise((resolve,reject) => { n === 0 && reject("try out fail at 5 tries: " + data);
                                           asyncFun(data).then(v => resolve("resolved at countdown " + n + ": " + v))
                                                         .catch(e => resolve(tryNTimes(data,asyncFun,--n)));
                                         });
}

function flowControl(d,f,tc){
  return d.reduce((prom,chunk) => prom.then(v => { console.log(v);
                                                   return tryNTimes(chunk,f,tc);
                                                 }),Promise.resolve("initial dummy promise"));
}

var data = ["chunk_1", "chunk_2", "chunk_3", "chunk_4", "chunk_5"],
asyncPro = promisify(async);                           // now our async function returns a promise

flowControl(data,asyncPro).then(v => console.log(v))
                          .catch(e => console.log(e));

如果您想更频繁地看到“5 次尝试”错误，请降低async() 函数中的超时值。