蓝鸟承诺的正确while（）循环（没有递归？）

1 回答

• 13

  这并不是100％清楚你想要做什么，但我会写一个答案来做你提到的以下事情：

  • 循环，直到满足代码中的某些条件

  • 允许您在循环迭代之间使用延迟

  • 允许您获取并处理最终结果

  • 与Bluebird一起使用（我将代码符合ES6承诺标准，该标准将与Bluebird或本机承诺一起使用）

  • 没有堆栈构建

  首先，假设您有一些异步函数返回一个promise，其结果用于确定是否继续循环 .

  function getNextItem() {
     return new Promise.delay(Math.random()*1000).then(function() {
          return(Math.floor(Math.random() * 1000));
     });
  }
  

  现在，您希望循环，直到返回的值满足某些条件

  function processLoop(delay) {
      return new Promise(function(resolve, reject) {
          var results = [];
  
          function next() {
              getNextItem().then(function(val) {
                  // add to result array
                  results.push(val);
                  if (val < 100) {
                      // found a val < 100, so be done with the loop
                      resolve(results);
                  } else {
                      // run another iteration of the loop after delay
                      setTimeout(next, delay);
                  }
              }, reject);
          }
          // start first iteration of the loop
          next();
      });
  }
  
  processLoop(100).then(function(results) {
     // process results here
  }, function(err) {
     // error here
  });
  

  如果你想让它更通用，那么你可以传递函数和比较，你可以这样做：

  function processLoop(mainFn, compareFn, delay) {
      return new Promise(function(resolve, reject) {
          var results = [];
  
          function next() {
              mainFn().then(function(val) {
                  // add to result array
                  results.push(val);
                  if (compareFn(val))
                      // found a val < 100, so be done with the loop
                      resolve(results);
                  } else {
                      // run another iteration of the loop after delay
                      if (delay) {
                          setTimeout(next, delay);
                      } else {
                          next();
                      }
                  }
              }, reject);
          }
          // start first iteration of the loop
          next();
      });
  }
  
  processLoop(getNextItem, function(val) {
      return val < 100;
  }, 100).then(function(results) {
     // process results here
  }, function(err) {
     // error here
  });
  

  ---

  您尝试这样的结构：

  return getNextItem() !== false;
  

  无法工作，因为 getNextItem() 返回一个始终为 !== false 的promise，因为promise是一个对象，因此无法工作 . 如果你想测试一个promise，你必须使用 .then() 来获取它的值，你必须异步执行comparson所以你不能直接返回这样的值 .

  ---

  注意：虽然这些实现使用调用自身的函数，但这不会导致堆栈堆积，因为它们会异步调用自身 . 这意味着在函数再次调用自身之前，堆栈已经完全展开，因此没有堆栈构建 . 从 .then() 处理程序始终是这种情况，因为Promise规范要求在堆栈返回"platform code"之前不调用 .then() 处理程序，这意味着它在调用 .then() 处理程序之前已解除所有常规"user code" .

  ---

  Using async and await in ES7

  在ES7中，您可以使用async并等待"pause"循环 . 这可以使这种类型的迭代更容易编码 . 这在结构上看起来更像是典型的同步循环 . 它使用 await 来等待promises，因为函数声明为 async ，它总是返回一个promise：

  function delay(t) {
      return new Promise(resolve => {
          setTimeout(resolve, t);
      });
  }
  
  async function processLoop(mainFn, compareFn, timeDelay) {
      var results = [];
  
      // loop until condition is met
      while (true) {
          let val = await mainFn();
          results.push(val);
          if (compareFn(val)) {
              return results;
          } else {
              if (timeDelay) {
                  await delay(timeDelay);
              }
          }
      }
  }
  
  processLoop(getNextItem, function(val) {
      return val < 100;
  }, 100).then(function(results) {
     // process results here
  }, function(err) {
     // error here
  });
  

  回复于 2024-04-30T13:41:53+08:00