Was sind die wesentlichen Promise-Retry-Entwurfsmuster für die Handhabung asynchroner Vorgänge?

Promise Retry Designs

Promises ermöglichen die asynchrone Programmierung und bieten einen flexiblen und effizienten Mechanismus für die Handhabung asynchroner Vorgänge. Es kann jedoch erforderlich sein, Muster zu entwerfen, um Szenarien zu bewältigen, in denen ein Versprechen Wiederholungsversuche erfordert. Hier stellen wir drei verschiedene Entwurfsmuster für Versprechenswiederholungen vor:

1. Wiederholen, bis das Versprechen gelöst wird (mit Verzögerung und MaxRetries)

<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 zur Bedingung des Ergebnisses (mit Verzögerung und MaxRetries)

<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);
        });
    })</code>

3. Speichereffizienter dynamischer Wiederholungsversuch (mit unbegrenzten Wiederholungsversuchen)

Wir untersuchen einen alternativen Ansatz, der auf dem Aufbau einer .catch()-Kette anstelle der üblichen .then()-Kette basiert:

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

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

Dieses Muster eignet sich für Szenarien mit einer begrenzten Anzahl von Wiederholungsversuche und eine niedrige maximale Anzahl, um Speicherverbrauchsprobleme zu vermeiden.

4. Erneut versuchen, bis das Ergebnis die Bedingung erfüllt (ohne 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);
}
p = p.then(processResult).catch(errorHandler);</code>

5. Erneut versuchen, bis das Ergebnis die Bedingung erfüllt (mit 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);
    // Don't simplify this to `p.catch(attempt).then(test, rejectDelay)` as test failures won't be caught.
}
p = p.then(processResult).catch(errorHandler);</code>

Das obige ist der detaillierte Inhalt vonWas sind die wesentlichen Promise-Retry-Entwurfsmuster für die Handhabung asynchroner Vorgänge?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!