$.when()

function aaa(){
	var dfd = $.Deferred();
	dfd.resolve();
	return dfd;
}

function bbb(){
	var dfd = $.Deferred();
	dfd.reject();
	//return dfd;
}

$.when( 123 , 456 ).done(function(){//这里的参数123,456，跟没有写参数是一样的，之后执行done里面的，不会走fail
	alert(arguments[0]);
	alert(arguments[1]);
	alert('成功');
}).fail(function(){
	alert('失败');
});

//上面的方式，when()里面某个参数函数没有返回延迟对象，默认会跳过这个，

// Deferred helper
			when: function( subordinate /* , ..., subordinateN */ ) {
				var i = 0,
					resolveValues = core_slice.call( arguments ),//传递进来的参数不是数组，在这里转成数组，这样就会有长度length
					length = resolveValues.length,//如果$.when()没有传参进来，则length为0,

					// the count of uncompleted subordinates
					//这里的remaining就是计数器，记录有几个是未完成状态
					//jQuery.isFunction( subordinate.promise )==>参数函数是否return延迟对象
					remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,

					// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
					//如果没有传递参数，remaining为0，这里就创建一个延迟对象：deferred = jQuery.Deferred()
					deferred = remaining === 1 ? subordinate : jQuery.Deferred(),

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

					progressValues, progressContexts, resolveContexts;

				// add listeners to Deferred subordinates; treat others as resolved
				if ( length > 1 ) {
					progressValues = new Array( length );
					progressContexts = new Array( length );
					resolveContexts = new Array( length );
					for ( ; i < length; i++ ) {
						if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
							resolveValues[ i ].promise()
								.done( updateFunc( i, resolveContexts, resolveValues ) )
								.fail( deferred.reject )
								.progress( updateFunc( i, progressContexts, progressValues ) );
						} else {
							--remaining;//如果when()中的参数不是函数或者参数函数没有返回一个延迟对象，则对计数器进行减1的操作，
						}
					}
				}

				// if we're not waiting on anything, resolve the master
				if ( !remaining ) {//如果没有传递参数或者remaining已经减为0，则立即执行延迟对象的resolveWith更新状态，只要resolve一触发，则对应的done也会触发
					deferred.resolveWith( resolveContexts, resolveValues );
				}

				return deferred.promise();
			}
			});