Haben Sie ein Versprechen, das viele Male abfragt, bis der Fehler nicht ausgelöst wird

Question

Sagen wir, es gibt ein Versprechen. checkOnSomeValue() und für die ersten zwei Sekunden vor dem Prozess ist das Versprechen checkOnSomeValue() abgelehnt. Dann löst das Versprechen nach etwa zwei Sekunden einen Wert auf.

Gibt es eine Möglichkeit, ein Versprechen zu umbrechen, sodass das Versprechen alle x Millisekunden ausgeführt werden kann, und dann das Wrapperversprechen aufzulösen, wenn das verschachtelte Versprechen aufgelöst wird?

Answer 1

Hier ist, was ich tun würde:

function poll(fn, ms) { 
    return fn().catch(e => Promise.delay(ms).then(() => poll(fn, ms))); 
} 

Grundsätzlich versuchen, die Funktion, wenn es ms Millisekunden warten, schlägt fehl, und dann erneut versuchen.

var polled = poll(checkOnSomeValue, 2000); 

polled().then(v => { 
    // your resolved value here ^_^ 
}); 

Oder mit Generatoren mit const co = Promise.coroutine:

const poll = co(function*(fn, ms) { 
    while(true) { 
     try { 
     return yield fn(); 
     } catch (e) { 
     yield Promise.delay(ms); 
     } // ignore rejections 
    } 
}); 

dem Sie die Rekursion vermeiden lässt.

Answer 2

Hier ist eine Möglichkeit.

function waiter() { 
    return new Promise((resolve) => { 
    let interval = setInterval(() => { 
     return client.getBalanceAsync('*', 6) 
     .then(value => { 
      clearInterval(interval) 
      return resolve(value) 
     }) 
     .catch((err) => { 
     }) 
    }, 200) 
    }) 
} 

Answer 3

würde ich gehe grundsätzlich mit Benjamins answer, aber in einer etwas anderen Implementierung:

function poll(fn, ms) { 
    var resolve =() => fn().catch(retry); 
    var retry =() => Promise.delay(ms).then(resolve); 
    return resolve(); 
} 

Keine große Sache. Aber aus irgendeinem Grund fühlt sich diese Ping-Pong-Implementierung besser/sauberer/besser lesbar für mich an. Kann nicht einmal argumentieren warum.