顺序运行Q承诺

Question

in a Node.js App, i want to achieve this: read an array, depend of item type, decide to use an specific function that returns a Q Promise object. i want this process runs sequentially.

i have this two Promises:

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

And this is main code:

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

But it does not work. because that fn1 has a Async process, it runs after fn2 . All i want is running these functions sequentially even one of them has Async process.

Answer 1

You can use .reduce to chain the promises.

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

Had something very similar to below cooking ... but fuyushimoya's just too fast, though we handle reduce's initialization differently

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

Sketching it out. But something like this might work.

UPD: the trick was to chain promises as it was mentioned in comments, there is updated version that I used for 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);
});