versprechen retray design musters

Einführung

Wenn asynchrone Operationen fehlschlagen, kann erneut eine wirksame Strategie sein, um vorübergehende Fehler zu behandeln. Dieser Artikel enthält verschiedene Muster für die Wiederholung von vielversprechenden Operationen und konzentriert sich auf drei gemeinsame Szenarien.

Muster Nr. 1: Wiederholung, bis das Versprechen auflöst

Dieses Muster übernimmt kontinuierlich ein Versprechen, bis er erfolgreich auflöst. Es gibt eine Verzögerung zwischen Wiederholungen und einer maximalen Anzahl von Versuchen an.

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

Muster #2: Wiederholen Sie, bis die Bedingung

dieses Muster trifft, bis eine Bedingung auf das Ergebnis des Versprechens erfüllt ist. Es gibt eine Verzögerung zwischen Wiederholungen und maximale Anzahl von Versuchen an.

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

Muster #3: Unbegrenzte Wiederholung mit Bedingung

Dieses Muster bietet eine an ermuteteneffizientes Weg, um unbegrenzte Zeiten wiederzuerlangen. Es gibt nur eine Verzögerung zwischen Wiederholungen an.

alternativen Ansatz unter Verwendung von .catch () ketten

Im Gegensatz zu den obigen Mustern erstellen dieser Ansatz eine .catch () -Kette, nicht eine .then () -Kette. Es begrenzt die Anzahl der Versuche und ist für Szenarien mit niedrigem Maximum geeignet, um übermäßigen Speicherkonsum zu vermeiden.

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

return bis beschluss, mit delay

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

for(var i=0; i 
  radry, bis die Bedingung trifft, nein delay  
 
var max = 5;
var p = Promise.reject();

for(var i=0; i 
  radry, bis die Bedingung mit Delay  
 
var max = 5;
var p = Promise.reject();

for(var i=0; i 
  schlussfolgerung  
 
 Diese Muster bieten vielseitige Möglichkeiten zur Implementierung der Wiederholungslogik für asynchrone Operationen. Unabhängig davon, ob .Catch () oder .then () -Ketten verwendet werden, hängt von den Anforderungen ab, z. B. Speicherverbrauch und maximale Anzahl von Versuchen.