Javascript 将延迟的数组传递给$.when（）

下面是一个人为的例子：

HTML:

JavaScript:

function getSomeDeferredStuff() {
    var deferreds = [];

    var i = 1;
    for (i = 1; i <= 10; i++) {
        var count = i;

        deferreds.push(
        $.post('/echo/html/', {
            html: "<p>Task #" + count + " complete.",
            delay: count
        }).success(function(data) {
            $("div").append(data);
        }));
    }

    return deferreds;
}

$(function() {
    $("a").click(function() {
        var deferreds = getSomeDeferredStuff();

        $.when(deferreds).done(function() {
            $("div").append("<p>All done!</p>");
        });
    });
});

函数getSomeDeferredStuff（）{ 风险值递延=[]； var i=1；

---

对于（i=1；i要将值数组传递给任何通常希望它们是单独参数的函数，请使用

function.prototype.apply

，因此在这种情况下，您需要：

$.when.apply($, my_array).then( ___ );

看

在ES6中，您可以使用

…

：

---

在这两种情况下，由于您不太可能预先知道

处理程序需要多少形式参数。那么
处理程序将需要处理
参数
数组，以便检索每个承诺的结果。
当
方法应用于数组时，您可以：

var arr = [ /* Deferred objects */ ];

$.when.apply($, arr);

上面的解决方法（谢谢！）没有正确地解决返回提供给延迟的
resolve（）
方法的对象的问题，因为jQuery调用
done（）
和
fail（）
使用单个参数而不是数组进行回调。这意味着我们必须使用
参数
伪数组来获取延迟数组返回的所有已解析/拒绝的对象，这很难看：

$.when.apply（$，延迟）。然后（function（）{
var objects=arguments；//作为伪数组的已解析对象数组
...
};

因为我们传入了一个延迟数组，所以最好返回一个结果数组。最好返回一个实际数组而不是伪数组，这样我们就可以使用类似于
array.sort（）
的方法

以下是一个受when.js的
when.all（）
方法启发的解决方案，该方法解决了以下问题：

//放在脚本环境中的某个地方
if（typeof jQuery.when.all=='undefined'）{
jQuery.when.all=函数（延迟）{
return$.Deferred（函数（def））{
$.when.apply（jQuery，延迟）。然后(
//调用函数将接收长度为N的数组，其中N是
//传递给when.all的延迟对象已成功。该数组中的每个元素都将
//它本身是一个由3个对象组成的数组，对应于传递给jqXHR.done的参数：
//（数据、文本状态、jqXHR）
函数（）{
var arrayThis，arrayArguments；
if（Array.isArray（this））{
arrayThis=这个；
arrayArguments=参数；
}
否则{
arrayThis=[这个]；
arrayArguments=[参数]；
}
resolveWith（arrayThis，[Array.prototype.slice.call（arrayArguments）]）；
},
//调用函数将接收长度为N的数组，其中N是
//传递给when.all的延迟对象失败。该数组中的每个元素都将
//它本身是一个由3个对象组成的数组，对应于传递给jqXHR.fail的参数：
//（jqXHR、textStatus、errorboorn）
函数（）{
var arrayThis，arrayArguments；
if（Array.isArray（this））{
arrayThis=这个；
arrayArguments=参数；
}
否则{
arrayThis=[这个]；
arrayArguments=[参数]；
}
def.rejectWith（arrayThis，[Array.prototype.slice.call（arrayArguments）]）；
});
});
}
}

现在，您只需传入一个延迟/承诺数组，并在回调中返回一个已解析/拒绝对象数组，如下所示：

$.when.all(deferreds).then(function(objects) {
    console.log("Resolved objects:", objects);
});

如果您使用的是angularJS或Q promise库的一些变体，那么您就有了一个
.all（）
方法来解决这个确切的问题

var savePromises = [];
angular.forEach(models, function(model){
  savePromises.push(
    model.saveToServer()
  )
});

$q.all(savePromises).then(
  function success(results){...},
  function failed(results){...}
);

请参阅完整的API：


作为一个简单的替代方案，它不需要
$。当.apply
或
数组
时，您可以使用以下模式为多个并行承诺生成单个承诺：

promise = $.when(promise, anotherPromise);

e、 g

函数GetSomeDeferredStuff（）{
//以一个空的已解析承诺开始（或者未定义的承诺也是如此！）
var承诺；
var i=1；
对于（i=1；i调用多个并行AJAX调用时，有两个选项用于处理相应的响应

使用同步AJAX调用/一个接一个/不推荐
使用
promise'
数组，该数组接受
promise
s及其回调
。当所有
promise
s成功返回并带有相应响应时，将调用done
示例


功能ajaxRequest（capitalCity）{
返回$.ajax({
网址：'https://restcountries.eu/rest/v1/capital/"资本,，
成功：功能（响应）{
},
错误：函数（响应）{
console.log（“错误”）
}
});
}
$（函数（）{
var capitalCities=[‘德里’、‘北京’、‘华盛顿’、‘东京’、‘伦敦’]；
$（'大写'）。文本（大写）；
函数getCountryCapitals（）{//执行多个并行ajax请求
var承诺=[]；
对于（var i=0，l=capitalCities.length；i我想用$提出另一个：

我们可能需要声明ajax函数，如：

function ajaxFn(someData) {
    this.someData = someData;
    var that = this;
    return function () {
        var promise = $.Deferred();
        $.ajax({
            method: "POST",
            url: "url",
            data: that.someData,
            success: function(data) {
                promise.resolve(data);
            },
            error: function(data) {
                promise.reject(data);
            }
        })
        return promise;
    }
}


我们使用ajax创建要发送的函数数组的代码部分：

var arrayOfFn = [];
for (var i = 0; i < someDataArray.length; i++) {
    var ajaxFnForArray = new ajaxFn(someDataArray[i]);
    arrayOfFn.push(ajaxFnForArray);
}


如果您正在传输并且可以访问ES6，则可以使用spread语法，该语法专门将对象的每个iterable项作为离散参数应用，就像
$.when（）
需要它一样

$.when(...deferreds).done(() => {
    // do stuff
});

我有一个非常类似的例子，我在一个each循环中发布，然后根据从ajax接收到的数字在一些字段中设置html标记。然后我需要对这些字段的值进行求和（现在已更新），并将其放在一个total字段中

所以问题是我
function ajaxFn(someData) {
    this.someData = someData;
    var that = this;
    return function () {
        var promise = $.Deferred();
        $.ajax({
            method: "POST",
            url: "url",
            data: that.someData,
            success: function(data) {
                promise.resolve(data);
            },
            error: function(data) {
                promise.reject(data);
            }
        })
        return promise;
    }
}

var arrayOfFn = [];
for (var i = 0; i < someDataArray.length; i++) {
    var ajaxFnForArray = new ajaxFn(someDataArray[i]);
    arrayOfFn.push(ajaxFnForArray);
}

$.when(
    $.each(arrayOfFn, function(index, value) {
        value.call()
    })
).then(function() {
        alert("Cheer!");
    }
)

$.when(...deferreds).done(() => {
    // do stuff
});

    // 1st
    function Outer() {
        var deferreds = GetAllData();

        $.when.apply($, deferreds).done(function () {
            // now you can do whatever you want with the updated page
        });
    }

    // 2nd
    function GetAllData() {
        var deferreds = [];
        $('.calculatedField').each(function (data) {
            deferreds.push(GetIndividualData($(this)));
        });
        return deferreds;
    }

    // 3rd
    function GetIndividualData(item) {
        var def = new $.Deferred();
        $.post('@Url.Action("GetData")', function (data) {
            item.html(data.valueFromAjax);
            def.resolve(data);
        });
        return def;
    }