Promise Retry Design Patterns: Uma abordagem com eficiência de memória

Ao usar Promises, repetir operações diante de falhas ou até que certas condições sejam atendida é uma necessidade comum. Neste artigo, exploraremos três padrões de design de nova tentativa do Promise:

1. Tentar novamente até que a promessa seja resolvida

Este padrão continua tentando até que a promessa seja resolvida. Ele especifica uma contagem máxima de novas tentativas e um atraso entre as tentativas.

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();
  });
};

2. Tentar novamente até que a condição no resultado seja atendida

Este padrão tenta novamente até que uma condição especificada seja atendida no resultado da promessa. Também inclui uma contagem máxima de novas tentativas e um atraso entre as tentativas.

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);

3. Novas tentativas dinâmicas com uso eficiente de memória

Este padrão usa uma abordagem recursiva, oferecendo tentativas ilimitadas com um atraso configurável.

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

for(var i=0; i
Ao construir uma cadeia .catch(), esse padrão permite implementações concisas de novas tentativas, especialmente em cenários com contagens máximas baixas de novas tentativas ou testes síncronos.
Cada um desses padrões fornece uma solução flexível e eficiente para repetir operações do Promise. Dependendo dos requisitos da sua aplicação, você pode escolher o padrão que melhor atende às suas necessidades.