Question

以下是云功能，即'batchReq1'和batchPromises。

在任何情况下，如果我知道推送的确切数量（在函数batchPromises（结果）中将结果的大小设置为'2'）并通过when（）执行，我可以通过传递它来处理成功响应在.then（）的successCallBack中的结果参数数量（在下面的示例中为request1，request2）。

如果我必须动态地处理推送到.when（）的promises数量，那么，我们如何在SuccessCallBack中处理它？与之前的方案不同，我们不能指望then方法中的固定结果数（batchPromises（results）.then（function（result1，result2）{....）

batchReq1

Parse.Cloud.define("batchReq1", function (request, response) {

    var results = request.params.imageArray;


    batchPromises(results).then(function (result1, result2) {

            console.log("Final Result:: Inside Success");

            console.log("Final Result:: Inside Success result 1::::"+result1);
            console.log("Final Result:: Inside Success result 2::::"+result2);

            response.success();

        }



//    batchPromises(results).then(function (arraySuccess) {
//
//        console.log("Final Result:: Inside Success");
//        console.log("Final Result:: Inside Success:: Length:: "+arraySuccess.length);
//        //Fetch all responses from promises and display
//        var _ = require('underscore.js');
//        _.each(arraySuccess, function (result) {
//
//            console.log("Final Result:: " + result)
//
//        });
//
//
//        response.success();
//
//    }



        , function (error) {
        console.log("Final Result:: Inside Error");
        response.error(error);

    });

});

batchPromises

function batchPromises(results) {

    var promise = Parse.Promise.as();
    var promises = [];


    var increment = 0;
    var isFromParallelExecution = false;


    var _ = require('underscore.js');
    _.each(results, function (result) {




        var tempPromise = Parse.Promise.as("Promise Resolved ");
        promises.push(tempPromise);
        }


            promise = promise.then(function () {

               return Parse.Promise.when(promises);

            });

        }
        increment++;
    });

    return promise;
}

Answer 1

您只需使用arguments object循环结果，或者构建arraySuccess而不使用when - 在批处理请求时无论如何都没有多大意义（按顺序执行它们，而不是并行执行它们：

function batchPromises(tasks) {
    var _ = require('underscore.js');
    _.reduce(tasks, function (promise, task) {
        return promise.then(function(resultArr) {
            var tempPromise = Parse.Promise.as("Promise Resolved for "+taks);

            return tempPromise.then(function(taskResult) {
                resultArr.push(taskResult);
                return resultArr;
            });
        });
    }, Parse.Promise.as([]));
}

如果您确实想要并行执行它们，请使用简单的

function batchPromises(tasks) {
    var _ = require('underscore.js');
    return Parse.Promise.when(_.map(tasks, function (task) {
        return Parse.Promise.as("Promise Resolved for "+taks);
    }).then(function() {
        return [].slice.call(arguments);
    });
}

Answer 2

这就是我处理这个问题的方法......

Parse.Cloud.define("xxx", function(request, response) 
{   
    var channels = ["channel1", "channel2", "channel3", "channel4", "channel5"];
    var queries = new Array();

    for (var i = 0; i < channels.length; i++)
    {
        var query = new Parse.Query(channels[i]);
        queries.push(query.find());
    }   

    Parse.Promise.when(queries).then(function()
    {
        var msg = "";
        for (var j = 0; j < arguments.length; j++)
        {       
            for (var k = 0; k < arguments[j].length; k++) 
            { 
                var object = arguments[j][k];
                msg = msg + "  " + object.get('somefield');
            }
        }
        response.success(msg);
    });
});

如何在承诺动态传递到.when（）的情况下成功处理每个响应成功的承诺

2 个答案: