如何阻止多个异步Parse云调用直到完成？

Question

I'm trying to achieve something very much like the following within Javascript on a Parse.com Cloud function:

Parse.Cloud.define("GatherThings", function(req, res) {
  var array_whatToGet = req.params.getThese;
  var returnVal = {};

  if(array_whatToGet.indexOf("Thing1") > -1) {
    Parse.Cloud.run("GetThing1", {}, {
      success: function(results) {
        returnVal['Thing1'] = results;
      } //ignoring error for now
    }
  }

  if(array_whatToGet.indexOf("Thing2") > -1) {
    Parse.Cloud.run("GetThing2", {}, {
      success: function(results) {
        returnVal['Thing2'] = results;
      } //ignoring error for now
    }
  }

  if(array_whatToGet.indexOf("Thing3") > -1) {
    Parse.Cloud.run("GetThing3", {}, {
      success: function(results) {
        returnVal['Thing3'] = results;
      } //ignoring error for now
    }
  }

  res.success(retVal);
}

Possible syntax errors here aside, when I try to do something like this I can get every called cloud function to run, but because of the async quality of these cloud functions I always get to retVal before anything finishes.

Can I somehow chain or block these in a way that they are not dependent on the other to run, but the final return is dependent on whether or not everything has finished?

Answer 1

This is just what promises are for. All of the Parse functions return promises, which can be given a method to run upon completion. Parse.Promise.when() takes an array of promises and is fulfilled when all of the passed promises are. We'd use it this way:

// underscore.js is a great general purpose utility, mostly self-explanatory
var _ = require('underscore');

Parse.Cloud.define("GatherThings", function(req, res) {
    var things = ["Thing1", "Thing2", "Thing3"];
    var array_whatToGet = req.params.getThese;
    var promises = [];
    _.each(things, function(thing) {
        if (_.contains(array_whatToGet, thing)) {
            promises.push(getThing(thing));
        }
    });
    Parse.Promise.when(promises).then(function(result) {
        res.success(result);
    }, function(error) {
        res.error(error);
    });
});

The question doesn't mention what GetThing1, GetThing2 and GetThing3 are, but it implies that they are other cloud functions. Calling Cloud.run from the cloud is at best unnecessary. Lets assume that the things specify some object to be queried and make a regular, non-cloud function that returns a promise to perform a query (which the Query methods all do).

function getThing(aThing) {
    var query = new Parse.Query("MyClass");
    query.equalTo("theThingProperty", aThing);
    // query.first() returns a promise that is fulfilled when the query is complete
    return query.first();
}