Question

我写了一些代码来每N ms进行一次资源轮询，这会在M秒后超时。我希望尽可能多地使用Bluebird做出承诺。到目前为止，我提出的解决方案使用节点间隔，可取消的蓝鸟承诺和蓝鸟的超时功能。

我想知道是否有更好的方法来实现蓝鸟和一般承诺的间隔时间？主要是通过确保间隔在该点停止并且永远不会无限期地继续。

var Promise = require('bluebird');

function poll() {
  var interval;

  return new Promise(function(resolve, reject) {
    // This interval never resolves. Actual implementation could resolve. 
    interval = setInterval(function() {
      console.log('Polling...')
    }, 1000).unref();
  })
    .cancellable()
    .catch(function(e) {
      console.log('poll error:', e.name);
      clearInterval(interval);
      // Bubble up error
      throw e;
    });
}

function pollOrTimeout() {
  return poll()
    .then(function() {
      return Promise.resolve('finished');
    })
    .timeout(5000)
    .catch(Promise.TimeoutError, function(e) {
      return Promise.resolve('timed out');
    })
    .catch(function(e) {
      console.log('Got some other error');
      throw e;
    });
}

return pollOrTimeout()
  .then(function(result) {
    console.log('Result:', result);
  });

输出：

Polling...
Polling...
Polling...
Polling...
poll error: TimeoutError
Result: timed out

Answer 1

我会做这样的事情 -

function poll() {
  return Promise.resolve().then(function() {
    console.log('Polling...');
    if (conditionA) {
      return Promise.resolve();
    } else if (conditionB) {
      return Promise.reject("poll error");
    } else {
      return Promise.delay(1000).then(poll);
    }
  })
    .cancellable()
}

另请注意Promise constructor anti-pattern

Answer 2

Rene Wooller提出了一个非常好的观点：

警告：不幸的是，像这样的javascript中的递归最终会使调用堆饱和并导致内存不足异常

即使它没有例外，这也是浪费的空间，异常的风险可能会导致超长的轮询延迟。

我认为这很重要，更喜欢setInterval：

var myPromise = new Promise((resolve, reject) => {
    var id = window.setInterval(() => {
        try {
            if (conditionA) {
                window.clearInterval(id);
                resolve("conditionA");
            } else if (conditionB) {
                throw new Error("conditionB!");
            }
        } catch(e) {
            window.clearInterval(id);
            reject(e);
        }
    }, 1000);
});

有一些npm包可以解决这个问题，我最喜欢promise-waitfor。这是38行长并完成工作。

var myPromise = waitFor(() => {
    if(conditionA) return true;
    if(conditionB) throw new Error("conditionB!");
    return false;
});

什么是＆＃34;间隔超时的好模式＆＃34;使用Promises

2 个答案: