Question

我正在学习nodejs中的promises，下面是我的示例代码。以下代码的输出是测试 - 1 测试 - 2 测试 - 3 测试 - 4

var Q = require('q');
var promise = Q.when('test');

promise.then( function(val) {
console.log(val + '-' + '1');
});

promise.then( function(val) {
 console.log(val + '-' + '2');
});

promise.then( function(val) {
 console.log(val + '-' + '3');
});

promise.then( function(val) {
console.log(val + '-' + '4');
});

我想知道如何使用for循环编写相同的代码。

Answer 1

这并不是真正的承诺。如果你在一个循环中创建回调，you'll need an extra closure scope，除此之外它是非常标准的。

但是，对于您的特定情况，最简单的方法是仅使用单个回调，因为它们都会附加到相同的承诺，并且将获得相同的值。所以你使用

require('q').when('test').then(function(val) {
    for (var i=1; i<=4; i++) {
        console.log(val + '-' + i);
    }
});

Answer 2

最后我能做到我想要，下面是代码

var Q = require('q'); 
var promise = Q.when('test');

for(var idx = 1 ; idx <= 4 ; idx++)
{
   (function()
   {
      var temp = idx;
       promise.then( function(val) {
             console.log(val + '-' + temp);
          });

   })();
}

它有效！我保证：）

Answer 3

来自q documentation：

如果要运行动态构造的函数序列，你会想要这样的东西：
var funcs = [foo, bar, baz, qux];

var result = Q(initialVal);
funcs.forEach(function (f) {
    result = result.then(f);
});
return result;

initialVal是Q.when('test')。

Answer 4

首先，自ES6以来有本机承诺，我认为使用库不是一个好主意，除非你必须支持旧的浏览器或旧的nodejs版本。

使用promises时，您正在使用异步代码，因此，您可以以不同的方式循环。

想象一下，你有这个片段：

function step1 (item){
  return new Promise((resolve, reject) => {
    setTimeout(()=>{
      resolve('step 1 for item ' + item);
    }, 1000);
  });
}

function step2 (item){
  return new Promise((resolve, reject) => {
     setTimeout(()=>{
       resolve('step 2 for item ' + item);
     }, 1000);
  });
}

function step3 (item){
  return new Promise((resolve, reject) => {
    setTimeout(()=>{
      resolve('step 3 for item ' + item);
    }, 1000);
  });
}

function processItem (item) {
  return step1(item).then(result =>{
     console.log(result);
     return step2(item);
  }).then(result =>{
     console.log(result);
     return step3(item);
  }).then(result =>{
     console.log(result);
     return ('finished process of item ' + item);
  }).catch(err =>{
     throw (err);
  });
}

其中processItem函数将应用于items数组。

：一种。运行一个环路。

上面的代码是异步的，所以，当你运行它时，然后inmediatly下一个执行，所以，如果processItem函数需要3秒才能完成，并且你想将该函数应用于10个项目，它将需要3秒因为Promise调用会被执行，但无需等待完成其中任何一个。

示例代码：

function promiseFor(set, fn){
    return new Promise((resolve, reject) => {
      return arr.map(item => ()=> fn(item)).forEach(proc => {
        return proc().then(res => {
          resolve();
        }).catch(err=>{
          console.log(err);
        });
      });
    });
}

的 B中。按顺序执行承诺。 在执行前一个序列之前，序列不会开始执行任何promise，这就像一个非异步的foor循环：例如：

function sequence (set, fn){
  return set.map(item => ()=> fn(item)).reduce((curr, next)=> {
    return curr.then(()=>{
      return next();
    })},Promise.resolve());
}

在nodejs中循环承诺

4 个答案: