Promise des modèles de conception de réchauffement

introduction

Lorsque les opérations asynchrones échouent, la réinscription peut être une stratégie efficace pour gérer les erreurs transitoires. Cet article présente divers modèles pour réessayer des opérations basées sur les promesses, en se concentrant sur trois scénarios communs.

motif # 1: RETRING jusqu'à ce que la promesse résout

ce modèle récupère continuellement une promesse jusqu'à ce qu'elle résout avec succès. Il spécifie un retard entre les tentatives et un nombre maximum de tentatives.

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

motif # 2: réessayer jusqu'à ce que la condition réponde

ce modèle révèle jusqu'à ce qu'une condition soit remplie sur le résultat de la promesse. Il spécifie un retard entre les tentatives et un nombre maximum de tentatives.

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

motif # 3: RETRAYE Illimited avec condition

Ce modèle fournit un moyen économe en mémoire de réessayer des temps illimités. Il spécifie seulement un délai entre les tentatives.

Approche alternative utilisant .catch () chaînes

Contrairement aux modèles ci-dessus, cette approche construit une chaîne .catch (), pas une chaîne .then (). Il limite le nombre de tentatives et convient aux scénarios à faible maximum pour éviter une consommation de mémoire excessive.

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

Réessayer jusqu'à résoudre, avec delage

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

for(var i=0; i 
  RETRY jusqu'à ce que la condition se réunit, pas de retard  
 
var max = 5;
var p = Promise.reject();

for(var i=0; i 
  RETRY jusqu'à ce que la condition se réunit, avec le retard  
 
var max = 5;
var p = Promise.reject();

for(var i=0; i 
  Conclusion  
 
 Ces modèles fournissent des moyens polyvalents d'implémenter la logique de retche pour les opérations asynchrones. Que l'utilisation de chaînes .catch () ou .then () dépend des exigences, telles que l'utilisation de la mémoire et le nombre maximum de tentatives.