我认为，要做到这一点最简单的方法就是保持辅助Deferred对象周围的每个AJAX请求，并确保这一个总是解决：

var d1 = $.Deferred();
var d2 = $.Deferred();

var j1 = $.getJSON(...).complete(d1.resolve);
var j2 = $.getJSON(...).complete(d2.resolve);

$.when(j1, j2).done(function() {
     // only fires if j1 AND j2 are resolved
});

$.when(d1, d2).done(function() {
     // will fire when j1 AND j2 are both resolved OR rejected
     // check j1.isResolved() and j2.isResolved() to find which failed
});

这是利用额外的 AJAX.complete()方法，jQuery 添加到其 AJAX 方法的Promise中，该方法对已解决和被拒绝的Promise均调用。

注意：d1.resolve它本身就是一个回调，它不需要被包裹在一个function() { ... }块中。

@Alnitak 的回答很聪明，并帮助我消除了我创建的一个 hack，在该 hack 中我有点人为地解决了一个Promise - 无论潜在的结果如何 - 为了我可以使用“when”来批量处理多个请求并使用“done”无论成功/失败，都继续前进。

我正在“回答”Alnitak 的回答，希望为他的建议提供另一种用途，该建议支持任意数量的潜在Promise。

var asyncFunc, entity, entities, $deferred, $deferreds;
// ...
foreach (entity in entities) {
    $deferred = $.Deferred();
    $deferreds.push($deferred);
    asyncFunc(entity).done(...).fail(...).always($deferred.resolve);
}
// ...
$.when.apply($, $deferreds).done(...)

这是伪 JavaScript，但它应该传达这种方法。对于一些任意大小的实体集，为每个实体创建一个延迟（$deferred）并将其推送到一个数组（$deferreds）上，进行异步调用，根据需要添加完成/失败，但始终包含一个“总是”来解决这个问题实体的 $deferred。注意“总是”接收延迟的解析函数而不是它的调用。

'when' 将 $deferreds 数组转换为 'when' 的参数列表，并且由于这组延迟可以保证解析（感谢 always），现在可以定义一个将被调用一次的 'done'无论这些是否成功/失败，异步调用都会完成。

我最近制作了一个可能有帮助的插件。我称之为$.whenAll。

此扩展将所有成功和失败视为进度事件。在所有的 Promise 完成后，如果没有错误，全局 Promise 就会被解析。否则全局Promise被拒绝。

$.whenAll - https://gist.github.com/4341799（测试）

示例用法：

$.whenAll($.getJSON('foo'), $.getJSON('bar'))
  .then(
    doneCallback
    ,failcallback
    // progress callback
    // the only problem is $.ajax.done/fail states call their callbacks 
    // with params in different locations (except for state)
    ,function(data, state, jqXhr) {
      if (state == 'success') {
        // do happy stuff
      }
      else { // error (fail)
        // `data` is actually the jqXhr object for failed requests
        // `jqXhr` is the text of the error "Not Found" in this example
      }
    }
  )
;

我的实现：

插件代码：

jQuery.whenAll = function (deferreds) {
        var lastResolved = 0;

        var wrappedDeferreds = [];

        for (var i = 0; i < deferreds.length; i++) {
            wrappedDeferreds.push(jQuery.Deferred());

            deferreds[i].always(function() {
                wrappedDeferreds[lastResolved++].resolve(arguments);
            });
        }

        return jQuery.when.apply(jQuery, wrappedDeferreds).promise();
    };

要使用它：

jQuery.whenAll([jQuery.get('/your-resource'), jQuery.get('/your-resource')])
   .done(
       function(result1, result2) {
           console.log(result1[1]);
           console.log(result2[1]);
       });

查看小提琴： http : //jsfiddle.net/LeoJH/VMQ3F/

这是我通过修改实际核心代码$.when()来使用您的语义制作的 jQuery 插件。想要一个更好的名字，它被称为$.myWhen()：

(function($) {
  $.myWhen = function( subordinate /* , ..., subordinateN */ ) {
    var i = 0,
      responseValues = Array.prototype.slice.call( arguments ),
      length = responseValues.length,

      // the count of uncompleted subordinates
      remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,

      // the master Deferred. If responseValues consist of only a single Deferred, just use that.
      deferred = remaining === 1 ? subordinate : jQuery.Deferred(),

      // Update function for all resolve, reject and progress values
      updateFunc = function( i, contexts, values ) {
        return function( value ) {
          contexts[ i ] = this;
          values[ i ] = arguments.length > 1 ? Array.prototype.slice.call( arguments ) : value;
          if( values === progressValues ) {
            deferred.notifyWith( contexts, values );
          } else if ( !( --remaining ) ) {
            deferred.resolveWith( contexts, values );
          }
        };
      },

      progressValues, progressContexts, responseContexts;

    // add listeners to Deferred subordinates; treat others as resolved
    if ( length > 1 ) {
      progressValues = new Array( length );
      progressContexts = new Array( length );
      responseContexts = new Array( length );
      for ( ; i < length; i++ ) {
        if ( responseValues[ i ] && jQuery.isFunction( responseValues[ i ].promise ) ) {
          responseValues[ i ].promise()
            .always( updateFunc( i, responseContexts, responseValues ) )
            .progress( updateFunc( i, progressContexts, progressValues ) );
        } else {
          --remaining;
        }
      }
    }

    // if we're not waiting on anything, resolve the master
    if ( !remaining ) {
      deferred.resolveWith( responseContexts, responseValues );
    }

    return deferred.promise();
  };
})(jQuery);

只需将此代码放在您加载 jQuery 的位置之后，该$.myWhen()函数就会与$.when(). 除了语义之外，其他一切都是 100% 完全相同的。