promise重试设计模式

Question

编辑

1. 继续重试直到promise解决的模式（具有延迟和最大重试次数）

#1的代码。不断重试，直到promise解决为止（语言社区有任何改进吗？）

Promise.retry = function(fn, times, delay) {
    return new Promise(function(resolve, reject){
        var error;
        var attempt = function() {
            if (times == 0) {
                reject(error);
            } else {
                fn().then(resolve)
                    .catch(function(e){
                        times--;
                        error = e;
                        setTimeout(function(){attempt()}, delay);
                    });
            }
        };
        attempt();
    });
};

使用

work.getStatus()
    .then(function(result){ //retry, some glitch in the system
        return Promise.retry(work.unpublish.bind(work, result), 10, 2000);
    })
    .then(function(){console.log('done')})
    .catch(console.error);

#2的代码继续重试，直到上的条件满足，然后以可重用的方式产生结果（条件是会发生变化的）。

work.publish()
    .then(function(result){
        return new Promise(function(resolve, reject){
            var intervalId = setInterval(function(){
                work.requestStatus(result).then(function(result2){
                    switch(result2.status) {
                        case "progress": break; //do nothing
                        case "success": clearInterval(intervalId); resolve(result2); break;
                        case "failure": clearInterval(intervalId); reject(result2); break;
                    }
                }).catch(function(error){clearInterval(intervalId); reject(error)});
            }, 1000);
        });
    })
    .then(function(){console.log('done')})
    .catch(console.error);

Answer 1

提到了许多好的解决方案，现在使用async/wait可以轻松解决这些问题。

如果你不介意递归方法，那么这就是我的解决方案。

function retry(fn, retries=3, err=null) {
  if (!retries) {
    return Promise.reject(err);
  }
  return fn().catch(err => {
      return retry(fn, (retries - 1), err);
    });
}

Answer 2

2.不断重试直到结果满足条件的模式（具有延迟和最大重试次数）

这是一种以递归方式处理本机promise的好方法：

const wait = ms => new Promise(r => setTimeout(r, ms));

const retryOperation = (operation, delay, retries) => new Promise((resolve, reject) => {
  return operation()
    .then(resolve)
    .catch((reason) => {
      if (retries > 0) {
        return wait(delay)
          .then(retryOperation.bind(null, operation, delay, retries - 1))
          .then(resolve)
          .catch(reject);
      }
      return reject(reason);
    });
});

假设func有时成功，有时失败，总是返回一个我们可以记录的字符串，则您可以这样称呼它：

retryOperation(func, 1000, 5)
  .then(console.log)
  .catch(console.log);

这里我们调用retryOperation，要求它每秒重试一次，最大重试次数=5。

如果你想要一些没有promise的更简单的东西，RxJs会提供帮助：https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/retrywhen.md

Answer 3

有点不同的东西...

异步重试可以通过构建来实现。catch（）链，与更常见的相反。然后（）链。

这种方法是：

• 只有在指定的最大尝试次数下才可能。（链必须是有限长度的），
• 仅建议使用低最大值。（Promise链消耗的内存大致与其长度成正比）。

否则，请使用递归解决方案。

首先，要用作<代码>的效用函数。catch（）回调。

var t = 500;

function rejectDelay(reason) {
    return new Promise(function(resolve, reject) {
        setTimeout(reject.bind(null, reason), t); 
    });
}

现在，您可以非常简洁地构建捕捉链：

1.延迟重试，直到promise解决为止

var max = 5;
var p = Promise.reject();

for(var i=0; i<max; i++) {
    p = p.catch(attempt).catch(rejectDelay);
}
p = p.then(processResult).catch(errorHandler);

演示：https://jsfiddle.net/duL0qjqe/

2.重试，直到结果满足某些条件，不要延迟

var max = 5;
var p = Promise.reject();

for(var i=0; i<max; i++) {
    p = p.catch(attempt).then(test);
}
p = p.then(processResult).catch(errorHandler);

演示：https://jsfiddle.net/duL0qjqe/1/

3.重试，直到结果满足某些条件，并延迟

考虑到（1）和（2），组合测试延迟同样微不足道。

var max = 5;
var p = Promise.reject();

for(var i=0; i<max; i++) {
    p = p.catch(attempt).then(test).catch(rejectDelay);
    // Don't be tempted to simplify this to `p.catch(attempt).then(test, rejectDelay)`. Test failures would not be caught.
}
p = p.then(processResult).catch(errorHandler);

test（）可以是同步或异步的。

添加进一步的测试也很简单。只需在两个渔获量之间夹一条鱼链。

p = p.catch(attempt).then(test1).then(test2).then(test3).catch(rejectDelay);

演示：https://jsfiddle.net/duL0qjqe/3/

所有版本都是为尝试成为一个返回promise的异步函数而设计的。它也可以返回一个值，在这种情况下，链将沿着其成功路径到达下一个/终端. then（）。