Promise Retry Design Patterns: Ein speichereffizienter Ansatz

Bei der Verwendung von Promises werden Vorgänge wiederholt, wenn Fehler auftreten oder bis bestimmte Bedingungen erfüllt sind erfüllt wird, ist ein allgemeines Bedürfnis. In diesem Artikel werden wir drei Promise-Retry-Entwurfsmuster untersuchen:

1. Wiederholen, bis das Versprechen aufgelöst ist

Dieses Muster wiederholt es so lange, bis das Versprechen aufgelöst ist. Es gibt eine maximale Anzahl von Wiederholungsversuchen und eine Verzögerung zwischen 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();
  });
};

2. Wiederholen, bis die Bedingung für das Ergebnis erfüllt ist

Dieses Muster wird wiederholt, bis eine bestimmte Bedingung für das Ergebnis des Versprechens erfüllt ist. Es umfasst auch eine maximale Anzahl von Wiederholungen und eine Verzögerung zwischen Versuchen.

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. Speichereffizienter dynamischer Wiederholungsversuch

Dieses Muster verwendet einen rekursiven Ansatz und bietet unbegrenzte Wiederholungsversuche mit einer konfigurierbaren Verzögerung.

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

for(var i=0; i
Durch den Aufbau einer .catch()-Kette ermöglicht dieses Muster präzise Wiederholungsimplementierungen, insbesondere in Szenarien mit niedrigen maximalen Wiederholungszahlen oder synchronen Tests.
Jedes dieser Muster bietet eine flexible und effiziente Lösung für die Wiederholung von Promise-Vorgängen. Abhängig von den Anforderungen Ihrer Anwendung können Sie das Muster auswählen, das Ihren Anforderungen am besten entspricht.