Wie implementiert man Promise-Retry-Entwurfsmuster für eine effiziente Fehlerbehandlung?

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 wird. Es gibt eine maximale Anzahl von Wiederholungen und eine Verzögerung zwischen den Versuchen an.

<code class="javascript">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();
  });
};</code>

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 beinhaltet auch eine maximale Anzahl von Wiederholungen und eine Verzögerung zwischen Versuchen.

<code class="javascript">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);</code>

3. Speichereffizienter dynamischer Wiederholungsversuch

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

<code class="javascript">var max = 5;
var p = Promise.reject();

for(var i=0; i<max; i++) {
    p = p.catch(attempt).then(test).catch(rejectDelay);
}
p = p.then(processResult).catch(errorHandler);</code>

Durch den Aufbau einer .catch()-Kette ermöglicht dieses Muster für prägnante 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.

Das obige ist der detaillierte Inhalt vonWie implementiert man Promise-Retry-Entwurfsmuster für eine effiziente Fehlerbehandlung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!