While-Schleife mit Bluebird verspricht

Question

Ich versuche, eine while-Schleife mit Versprechen zu implementieren.

Die hier beschriebene Methode scheint zu funktionieren. http://blog.victorquinn.com/javascript-promise-while-loop verwendet es eine Funktion wie diese

var Promise = require('bluebird'); 

var promiseWhile = function(condition, action) { 
    var resolver = Promise.defer(); 

    var loop = function() { 
     if (!condition()) return resolver.resolve(); 
     return Promise.cast(action()) 
      .then(loop) 
      .catch(resolver.reject); 
    }; 

    process.nextTick(loop); 

    return resolver.promise; 
}; 

Dies scheint anti-Muster zu verwenden und veraltete Methoden wie Guss- und verschieben.

Kennt jemand einen besseren oder moderneren Weg, dies zu erreichen?

Dank

Answer 1

cast kann resolve übersetzt werden. defer sollte indeed not be used.

Sie würden Ihre Schleife nur durch Verkettung und Verschachtelung von then Invokationen auf eine ursprüngliche Promise.resolve(undefined) erstellen.

function promiseWhile(predicate, action, value) { 
    return Promise.resolve(value).then(predicate).then(function(condition) { 
     if (condition) 
      return promiseWhile(predicate, action, action()); 
    }); 
} 

Hier sind sowohl predicate und action kann Versprechungen zurück. Für ähnliche Implementierungen auch einen Blick auf Correct way to write loops for promise. Näher an Ihrer ursprünglichen Funktion

function promiseWhile(predicate, action) { 
    function loop() { 
     if (!predicate()) return; 
     return Promise.resolve(action()).then(loop); 
    } 
    return Promise.resolve().then(loop); 
} 

Answer 2

ich diese Implementierung lieber als wäre einfacher haben Pause zu simulieren und damit weiter:

var Continue = {}; // empty object serves as unique value 
var again = _ => Continue; 

var repeat = fn => Promise.try(fn, again) 
    .then(val => val === Continue && repeat(fn) || val); 

Beispiel 1: stoppt, wenn entweder die Quelle oder das Ziel einen Fehler anzeigen

repeat(again => 
    source.read() 
    .then(data => destination.write(data)) 
    .then(again) 

Beispiel 2: Nach dem Zufall stoppen, wenn die Münzflip 90% Wahrscheinlichkeit Ergebnisse entsprechen wit h a 0

var blah = repeat(again => 
    Promise.delay(1000) 
    .then(_ => console.log("Hello")) 
    .then(_ => flipCoin(0.9) && again() || "blah")); 

Beispiel 3: Schleife mit Bedingung, dass die Summe zurück:

repeat(again => { 
    if (sum < 100) 
    return fetchValue() 
     .then(val => sum += val) 
     .then(again)); 
    else return sum; 
})