Verspricht: Wiederholen Sie die operation, bis es gelingt?

Will ich führen eine operation wiederholt, mit Zunehmender Wartezeit zwischen den einzelnen Betrieb, bis er erfolgreich ist oder eine gewisse Zeit verstreicht. Wie strukturiere ich diese mit Versprechungen in F?

Wenn Sie möchten, eine rekursive snippet mit einheimischen verspricht und max Wiederholungen, check this: stackoverflow.com/a/44577075/3032209

InformationsquelleAutor Jay Bienvenu | 2014-11-01

24

Alle, die Antworten hier sind wirklich kompliziert meiner Meinung nach. Kos hat die richtige Idee, aber Sie verkürzen den code schreiben mehr idiomatische Versprechen-code:
```
function retry(operation, delay) {
    return operation().catch(function(reason) {
        return Q.delay(delay).then(retry.bind(null, operation, delay * 2));
    });
}
```
Und mit Kommentaren:
```
function retry(operation, delay) {
    return operation(). //run the operation
        catch(function(reason) { //if it fails
            return Q.delay(delay). //delay 
               //retry with more time
               then(retry.bind(null, operation, delay * 2)); 
        });
}
```
Wenn Sie wollen, zu mal es Sie nach einer gewissen Zeit (sagen wir 10 Sekunden , können Sie einfach tun:
```
var promise = retry(operation, 1000).timeout(10000);
```
Ist diese Funktionalität direkt in Q, keine Notwendigkeit, neu zu erfinden 🙂
- Dies ist ein wirklich toller Vorschlag. Allerdings fand ich ein Problem mit ihm. Auch wenn das timeout abläuft, wird die wiederholen-Funktion bleiben wird, nennt sich selbst, bis es gelingt, die offensichtlich könnte unendlich sein. Gibt es eine saubere Art und Weise zu brechen, das Versprechen, die Kette, wenn das timeout Auftritt, so dass nicht mehr-Handler aufgerufen werden, oder wir sind festgefahren, nachdem ein flag zu setzen, oder gar aufzugeben timeout() zu Gunsten einer nrAttempts Zähler inkrementiert bei jedem Aufruf von operation() und überprüft, einige beschränken?
- wenn Sie lassen Sie mich bluebird verwende ich eine Stornierung, sonst würden Sie verwenden einen speziellen Verschluss Variablen zu simulieren - oder pass-ein "token" (variable) in die Wiederholungen, und setzen Sie ihn auf false. Es gibt also Möglichkeiten, aber keine wirklich saubere Art und Weise mit Q.
- Natürlich gibt es Möglichkeiten. Ich löste es, sehr einfach mit einem maxAttempts und einen Zähler, und übersprungen, mit timeout zusammen. Mein Anliegen ist es, mehr mit der Tatsache, dass die Antwort oben ist falsch in dieser Hinsicht, und wenn Sie nicht aufpassen, könnten die Menschen am Ende der Laichzeit unendlichen Operationen, die eine erhebliche Menge an cpu-Zeit.
- Ganz ehrlich - der timeout ist in Ordnung - die Frage ist, mit Ausnahmen für flow-control, um mit zu beginnen - es würde mehr Sinn machen, keine Ausnahmen für flow-control, sondern ein Ergebnis zurückgeben - und wenn das Ergebnis nicht erfolgreich ist, dann tötet die Bedienung - so eine Zeitüberschreitung lassen Sie sich einfach zu einer Ausnahme von der Innenseite der die Verhalten Sie erwarten. Das sagte - feel free to post eine alternative Antwort.
- Kos' Lösung für mich gearbeitet. Diese Lösung aber nicht :-/ . Nicht sicher, warum. Ich ging die Funktion auf die gleiche Weise...
- Diese ist sehr leistungsstark Dank!
- Kann das getan werden, ohne Rekursion?
- Q ist eine Bibliothek. Sie können ersetzen Q.delay(N) mit new Promise(r => setTimeout(r, N)) und Leben happily ever after 🙂
- danke, ich entfernte meine Frage, denn dann sah ich den tag q auf die OP-Frage, aber vielen Dank für die Beantwortung so schnell.
- schöne kompakte Funktion. Dennoch kann ich nicht verwenden Sie diesen Ansatz, da meine Funktion operation() als solche wirft einen Fehler, noch vor dem Aufruf wiederholen, da der laden meiner function operation() abgegrenzt. Gibt es irgendeine Abhilfe?
- Ein Versprechen der Rückkehr, sollte die Funktion nie wirft einen Fehler. Das heißt, Sie können Q.try um ihn herum (oder Promise.resolve().then(operation) in die Muttersprache verspricht Fall).
- nochmals vielen Dank. Ich weiß, man kann es nicht Versprechen, aber ich habe meine Lösung: stackoverflow.com/a/53032624/1243247
InformationsquelleAutor Benjamin Gruenbaum

Hier ist ein Beispiel, wie würde ich diesen Ansatz, mit einigen Hilfsfunktionen. Hinweis, die "maxTimeout" ist der kompliziertere Teil, da Sie die Rennen in zwei Staaten.

//Helper delay function to wait a specific amount of time.
function delay(time){
    return new Promise(function(resolve){
        setTimeout(resolve, time);
    });
}

//A function to just keep retrying forever.
function runFunctionWithRetries(func, initialTimeout, increment){
    return func().catch(function(err){
        return delay(initialTimeout).then(function(){
            return runFunctionWithRetries(
                    func, initialTimeout + increment, increment);
        });
    });
}

//Helper to retry a function, with incrementing and a max timeout.
function runFunctionWithRetriesAndMaxTimeout(
        func, initialTimeout, increment, maxTimeout){

    var overallTimeout = delay(maxTimeout).then(function(){
        //Reset the function so that it will succeed and no 
        //longer keep retrying.
        func = function(){ return Promise.resolve() };
        throw new Error('Function hit the maximum timeout');
    });

    //Keep trying to execute 'func' forever.
    var operation = runFunctionWithRetries(function(){
        return func();
    }, initialTimeout, increment);

    //Wait for either the retries to succeed, or the timeout to be hit.
    return Promise.race([operation, overallTimeout]);
}

Dann zu verwenden, die diese Helfer, würden Sie so etwas tun:

//Your function that creates a promise for your task.
function doSomething(){
    return new Promise(...);
}

runFunctionWithRetriesAndMaxTimeout(function(){
    return doSomething();
}, 1000 /* start at 1s per try */, 500 /* inc by .5s */, 30000 /* max 30s */);

InformationsquelleAutor loganfsmyth

2

Ich denke, man kann nicht auf der Ebene Versprechen - ein Versprechen, das nicht ein Betrieb, sondern ist nur ein Wert, der ankommen in der Zukunft, so kann man nicht eine Funktion definieren, die zusammengenommen Promise -> Promise, die es erreichen werden.

Müssten Sie gehen eine Ebene nach unten und definieren Sie eine Funktion eingegeben Operation -> Promise wo Betrieb ist selbst eingegeben () -> Promise. Ich nehme an, die Bedienung nimmt keine Parameter - Sie können teilweise gelten Sie im Voraus.

Hier ein rekursiver Ansatz, verdoppelt sich der timeout auf jedem Lauf:
```
function RepeatUntilSuccess(operation, timeout) {
    var deferred = Q.defer();
    operation().then(function success(value) {
        deferred.resolve(value);
    }, function error(reason) {
        Q.delay(timeout
        .then(function() {
            return RepeatUntilSuccess(operation, timeout*2);
        }).done(function(value) {
            deferred.resolve(value);
        });
    });
    return deferred.promise;
}
```
Demo: http://jsfiddle.net/0dmzt53p/
- Warum das zurückgestellt? Können Sie Versprechen Verkettung.
- Cool, danke für das zeigen von mir! Noch lernen, diese, die ich immer am Ende nicht einfach genug. (Noch nicht bekam, um zu versuchen, Ihnen außerhalb der Geigen")
- Gut, ich schrieb eine Q&A zu diesem Problem basierend auf PET ' ka ist (link dorthin).
InformationsquelleAutor Kos

Weisen eine Boolesche variable für "alle Prozess-timeout".
Rufen Sie den window setTimeout zu machen, dass die variable "falsch" nach, dass "alle Prozess-timeout".
Rufen Sie Versprechen den Betrieb mit einem timeout.
Wenn es gelingt, kein problem.
Wenn es versagt: Im Versprechen, einen Fehler-handler, rufen Sie Versprechen-Funktion wieder mit einem erhöhten timeout, wenn die boolean-variable true ist.

Etwas wie dieses:

var goOn= true;

setTimeout(function () {
    goOn= false;
}, 30000); //30 seconds -- all process timeout


var timeout = 1000; //1 second

(function () {
    var helperFunction = function () {

        callAsyncFunc().then(function () {
            //success...
        }, function () {
            //fail
            if (goOn) {
                timeout += 1000; //increase timeout 1 second
                helperFunction();
            }
        }).timeout(timeout);

    }
})();

Ich glaube, Sie könnten verwirrt über das, was .timeout tut (eigentlich tut, was Sie verwenden goOn nur es ist gebaut in der Bibliothek).

InformationsquelleAutor Kursad Gulseven

Habe ich Folgendes mit Promises/A+ (die sollten in Ordnung sein mit Q)

function delayAsync(timeMs)
{
    return new Promise(function(resolve){
        setTimeout(resolve, timeMs);
    });
}

//use an IIFE so we can have a private scope
//to capture some state    
(function(){
    var a;
    var interval = 1000;
    a = function(){
        return doSomethingAsync()
            .then(function(success){
                if(success)
                {
                    return true;
                }
                return delayAsync(interval)
                         .then(function(){
                             interval *= 2;
                         })
                         .then(a());
            });
    };
    a();
})();

Ich bin sicher, dass Sie herausfinden könnten wie man die Kaution nach maximal timeout.

Meinten Sie rufen a?
Ja. Traurig über den Wegfall.

InformationsquelleAutor spender

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.