Patrones de diseño de reintento de promesas: un enfoque eficiente en la memoria

Al usar promesas, reintentar operaciones ante fallas o hasta que se cumplan ciertas condiciones satisfacer es una necesidad común. En este artículo, exploraremos tres patrones de diseño de reintento de Promise:

1. Reintentar hasta que se resuelva la promesa

Este patrón sigue reintentando hasta que se resuelva la promesa. Especifica un recuento máximo de reintentos y un retraso entre intentos.

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. Reintentar hasta que se cumpla la condición del resultado

Este patrón reintenta hasta que se cumpla una condición específica en el resultado de la Promesa. También incluye un recuento máximo de reintentos y un retraso entre intentos.

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. Reintento dinámico con eficiencia de memoria

Este patrón utiliza un enfoque recursivo y ofrece reintentos ilimitados con un retraso configurable.

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

for(var i=0; i
Al crear una cadena .catch(), este patrón permite implementaciones de reintento concisas, especialmente en escenarios con recuentos máximos de reintentos bajos o pruebas sincrónicas.
Cada uno de estos patrones proporciona una solución flexible y eficiente para reintentar las operaciones de Promise. Dependiendo de los requisitos de tu aplicación, podrás elegir el patrón que mejor se adapte a tus necesidades.