Javascript 承诺多次轮询，直到不会抛出错误

比如说有一个承诺

checkOnSomeValue（）

在流程启动前的前两秒钟，承诺

checkOnSomeValue（）

被拒绝。然后大约两秒钟后，promise解析出一个值

有没有一种方法可以包装一个承诺，这样承诺可以每x毫秒运行一次，然后在嵌套承诺解析时解析包装承诺？

这里有一种方法

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

这里有一条路

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

---

下面是我要做的：

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

这样可以避免递归。
下面是我要做的：

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

这让您可以避免递归。
我基本上同意，但在一个稍微不同的实现中：

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

没什么大不了的。但出于某种原因，我觉得这个乒乓球实现更好/更干净/更具可读性。甚至无法解释原因。
我基本上同意，但在一个稍微不同的实现中：

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

没什么大不了的。但出于某种原因，我觉得这个乒乓球实现更好/更干净/更具可读性。甚至无法解释原因。
你能更明确地说明你的例子吗？一些示例代码会更好，您能更明确地说明您的示例吗？一些示例代码会更好您不应该在这里使用
setInterval
，但是
setTimeout
，否则您可能会
多次解析
承诺，如果
getBalanceAsync
持续时间更长，则
200ms
setTimeout
只调用一次承诺。我需要一种多次调用它的方法。这是延迟反模式，你知道得更清楚。@t.niese多次解析承诺很好（它可以工作，并且只解析一次），问题是函数本身被多次并发调用。这里不应该使用
setInterval
，而应该使用
setTimeout
，否则，您可能会多次解析该承诺，如果
getBalanceAsync
持续时间更长，则
200ms
setTimeout
只调用该承诺一次。我需要一种多次调用的方法。这是延迟反模式，你知道得更清楚。@t.niese多次解析承诺很好（它可以工作，并且只解析一次），问题是函数本身被并发调用多次。