Question

我们说这是一个承诺。 checkOnSomeValue()并且在流程启动前的前两秒钟，承诺checkOnSomeValue()被拒绝。然后大约两秒后，诺言会解析一个值。

有没有办法包装一个promise，以便每隔x毫秒运行一次promise，然后在嵌套的promise解析后解析包装器的承诺？

Answer 1

以下是我要做的事情：

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

基本上，尝试该函数，当它失败时等待ms毫秒，然后再试一次。

var polled = poll(checkOnSomeValue, 2000);

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

或者使用const co = Promise.coroutine生成器：

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

可以避免递归。

Answer 2

这是一种方式。

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

我基本上会使用Benjamins answer，但实现方式略有不同：

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

没什么大不了的。但由于某些原因，这种乒乓球实现感觉更好/更清洁/更易读。甚至无法论证原因。

承诺多次轮询，直到错误没有被抛出

3 个答案: