要将一组值传递给通常希望它们是单独参数的任何函数，请使用Function.prototype.apply，因此在这种情况下，您需要：

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

见http://jsfiddle.net/YNGcm/21/

在 ES6 中，您可以改用... 展开运算符：

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

在任何一种情况下，由于您不太可能事先知道.then处理程序需要多少正式参数，因此该处理程序需要处理arguments数组以检索每个Promise的结果。

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

$.when.apply($,deferreds).then(function() {
     var objects = arguments; // The array of resolved objects as a pseudo-array
     ...
};

因为我们传入了一个延迟数组，所以返回一个结果数组会很好。返回一个实际数组而不是伪数组也很好，这样我们就可以使用像Array.sort().

这里是通过激发溶液when.js的when.all()方法，该方法解决了这些问题：

// Put somewhere in your scripting environment
if (typeof jQuery.when.all === 'undefined') {
    jQuery.when.all = function (deferreds) {
        return $.Deferred(function (def) {
            $.when.apply(jQuery, deferreds).then(
            // the calling function will receive an array of length N, where N is the number of
            // deferred objects passed to when.all that succeeded. each element in that array will
            // itself be an array of 3 objects, corresponding to the arguments passed to jqXHR.done:
            // ( data, textStatus, jqXHR )
            function () {
                var arrayThis, arrayArguments;

                if (Array.isArray(this)) {
                    arrayThis = this;
                    arrayArguments = arguments;
                }
                else {
                    arrayThis = [this];
                    arrayArguments = [arguments];
                }

                def.resolveWith(arrayThis, [Array.prototype.slice.call(arrayArguments)]);
            },
            // the calling function will receive an array of length N, where N is the number of
            // deferred objects passed to when.all that failed. each element in that array will
            // itself be an array of 3 objects, corresponding to the arguments passed to jqXHR.fail:
            // ( jqXHR, textStatus, errorThrown )
            function () {
                var arrayThis, arrayArguments;

                if (Array.isArray(this)) {
                    arrayThis = this;
                    arrayArguments = arguments;
                }
                else {
                    arrayThis = [this];
                    arrayArguments = [arguments];
                }

                def.rejectWith(arrayThis, [Array.prototype.slice.call(arrayArguments)]);
            });
        });
    }
}

现在您可以简单地传入一组延迟/Promise并在您的回调中取回一组已解决/拒绝的对象，如下所示：

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

您可以将该when方法应用于您的数组：

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

$.when.apply($, arr);

你如何使用 jQuery Deferreds 数组？

当调用多个并行 AJAX 调用时，您有两个选项来处理各自的响应。

1. 使用同步 AJAX 调用/一个接一个/不推荐
2. 使用Promises'array 并且$.when它接受promises 并且.done当所有promises 成功返回并带有相应的响应时，它的回调被调用。

例子

function ajaxRequest(capitalCity) {
   return $.ajax({
        url: 'https://restcountries.eu/rest/v1/capital/'+capitalCity,
        success: function(response) {
        },
        error: function(response) {
          console.log("Error")
        }
    });
}
$(function(){
   var capitalCities = ['Delhi', 'Beijing', 'Washington', 'Tokyo', 'London'];
   $('#capitals').text(capitalCities);

   function getCountryCapitals(){ //do multiple parallel ajax requests
      var promises = [];   
      for(var i=0,l=capitalCities.length; i<l; i++){
            var promise = ajaxRequest(capitalCities[i]);
            promises.push(promise);
      }
  
      $.when.apply($, promises)
        .done(fillCountryCapitals);
   }
  
   function fillCountryCapitals(){
        var countries = [];
        var responses = arguments;
        for(i in responses){
            console.dir(responses[i]);
            countries.push(responses[i][0][0].nativeName)
        }  
        $('#countries').text(countries);
   }
  
   getCountryCapitals()
})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div>
  <h4>Capital Cities : </h4> <span id="capitals"></span>
  <h4>Respective Country's Native Names : </h4> <span id="countries"></span>
</div>

作为一个简单的替代方案，不需要$.when.apply或array，您可以使用以下模式为多个并行Promise生成单个Promise：

promise = $.when(promise, anotherPromise);

例如

function GetSomeDeferredStuff() {
    // Start with an empty resolved promise (or undefined does the same!)
    var promise;
    var i = 1;
    for (i = 1; i <= 5; i++) {
        var count = i;

        promise = $.when(promise,
        $.ajax({
            type: "POST",
            url: '/echo/html/',
            data: {
                html: "<p>Task #" + count + " complete.",
                delay: count / 2
            },
            success: function (data) {
                $("div").append(data);
            }
        }));
    }
    return promise;
}

$(function () {
    $("a").click(function () {
        var promise = GetSomeDeferredStuff();
        promise.then(function () {
            $("div").append("<p>All done!</p>");
        });
    });
});

笔记：

• 在看到有人按顺序使用链式Promise后，我想出了这个 promise = promise.then(newpromise)
• 缺点是它在幕后创建了额外的 promise 对象，并且最后传递的任何参数都不是很有用（因为它们嵌套在其他对象中）。对于你想要的，虽然它简短而简单。
• 好处是它不需要阵列或阵列管理。