promete volver a intentar los patrones de diseño

introducción

cuando las operaciones asíncronas fallan, el retintino puede ser una estrategia efectiva para manejar errores transitorios. Este artículo presenta varios patrones para volver a intentar las operaciones basadas en la promesa, centrándose en tres escenarios comunes.

Patrón #1: Vuelva a intentar hasta que la promesa se resuelva

Este patrón vuelve continuamente una promesa hasta que se resuelva con éxito. Especifica un retraso entre reintentos y un número máximo de 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();
    });
};

Patrón #2: Vuelva a intentar hasta que la condición se reúna

este patrón se reponga hasta que se cumpla una condición en el resultado de la promesa. Especifica un retraso entre reintentos y un número máximo de 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);

patrón #3: reintento ilimitado con condición

Este patrón proporciona una forma eficiente en memoria de volver a intentarlo. Solo especifica un retraso entre reintentos.

enfoque alternativo usando .catch () cadenas

a diferencia de los patrones anteriores, este enfoque construye una cadena .catch (), no una cadena .then (). Limita el número de intentos y es adecuado para escenarios de bajo máximo para evitar el consumo de memoria excesivo.

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

reintentar hasta que se resuelva, con demora

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

for(var i=0; i 
  hasta que la condición se reúna, sin demora  
 
var max = 5;
var p = Promise.reject();

for(var i=0; i 
  hasta que la condición se reúna, con demora  
 
var max = 5;
var p = Promise.reject();

for(var i=0; i 
  Conclusión  
 
 Estos patrones proporcionan formas versátiles de implementar la lógica de reintento para operaciones asíncronas. Si usando las cadenas .catch () o .then () depende de los requisitos, como el uso de la memoria y el número máximo de intentos.