顺序运行 Q Promises

Question

在Node.js 应用程序中，我想实现这一点： 读取数组，取决于项目类型，决定使用返回 Q Promise 对象的特定函数。我希望这个过程按顺序运行。

我有这两个承诺：

var q = require('q');
Classes.prototype.fn1 = function (item) {
    return q.Promise(function(resolve, reject){
        Items.find({item_published: true}).exec(
            function (err, events) {
                if (err) {
                    reject('an error happened');
                    throw err;
                }else{
                    resolve(events);
                }
        });
    });
};

Classes.prototype.fn2 = function (item) {
    return q.Promise(function(resolve, reject){
        resolve(item);
    });
};

这是主要代码：

self.items = [{},{},{}]; //some items
self.result = [];

self.items.forEach(function(item,index,array){

    if(item.type == 1){
        self.fn1(item)
            .then(function(result){
                self.result.push(result);
        })
    }

    if(item.type == 2){
        self.fn2(item)
            .then(function(result){
                self.result.push(result);
        })
    }

    if(index == array.length-1){
        callback(self.result);
     }
});

但它不起作用。因为fn1 有一个异步进程，所以它在fn2 之后运行。我想要的只是顺序运行这些函数，即使其中一个具有异步进程。

Answer 1

您可以使用.reduce 链接承诺。

var promise = q(); // Create a Resolved promise for chaining.
self.items = [{},{},{}]; //some items
self.result = [];

// We put an resolved promise as init value for chaining
self.items.reduce(function(chain, item) {
    // Don't do anything if item type is not match
    if (item.type !== 1 && item.type !== 2) {
      return chain;
    }

    var targetFunc = null;
    if (item.type === 1) {
      targetFunc = self.fn1;
    } else if (item.type === 2) {
      targetFunc = self.fn2;
    }

    if (targetFunc === null) {
      return chain;
    }

    // Chain the promise and return the last of the chain.
    return chain
      .then(function(){
        return targetFunc(item);
      })
      .then(function(result){
        // This then will get the result from above
        // so we put the result to self.result here
        self.result.push(result);
      });
}, promise).then(function() {
  // When all promises are sequentially resolved,
  // call the callback with self.resul.
  callback(self.result);
});

jsfiddle, jsfiddle-Q.js ver.

Answer 2

有一些非常类似于下面的烹饪......但是 fuyushimoya 太快了，虽然我们处理 reduce 的初始化不同

var promises = self.items.map( function(item) {
    if (item.type == 2) {
      return self.fn1(item);
    }
    else if (item.type == 3) {
      return self.fn2(item);
    }
 });

function handler(p) {
  return p.then( function(res) {
    self.result.push(res);
  });
}

promises
 .reduce( function(prev, current) {
  if (prev) {
    return prev.then( function() { handler(current) } )
  } 
  else {
    return handler(current)
  }
})
 .then(function(result) {
    callback(null, result);
  })
  .catch( // error handler);

Answer 3

画出来。但这样的事情可能会奏效。

UPD：诀窍是链接承诺，正如 cmets 中提到的那样，我用于 code snippet here 的更新版本：

 var items = [{type:1},{type:2},{type:1}];
 var result = [];
 var rq = Q();
 var ql = rq;

 items.forEach(function (it, ix) {

    ql = ql.then(function(){
      var dp = "fn" + it.type;
      return ps[dp]();
    })
    .then(function(d) {
      result.push(d);
    });
 });

ql.then(function() {
  callback(result);
});