jQuery.extend({
/*
* deferred对象的一大好处，就是它允许你自由添加多个回调函数。
* $.ajax("test.html")
.done(function(){ alert("哈哈，成功了！");} )
.fail(function(){ alert("出错啦！"); } )
.done(function(){ alert("第二个回调函数！");} );
*deferred对象的另一大好处，就是它允许你为多个事件指定一个回调函数，这是传统写法做不到的。
当两个操作都成功了才执行成功的回调函数，否则执行失败的回调函数
$.when($.ajax("test1.html"), $.ajax("test2.html"))
.done(function(){ alert("哈哈，成功了！"); })
.fail(function(){ alert("出错啦！"); });
*deferred对象的最大优点，就是它把这一套回调函数接口，从ajax操作扩展到了所有操作。
也就是说，任何一个操作----不管是ajax操作还是本地操作，也不管是异步操作还是同步操作----
都可以使用deferred对象的各种方法，指定回调函数。
*deferred对象有三种执行状态----未完成，已完成和已失败。
*/
Deferred: function( func ) {
var tuples = [
// action, add listener, listener list, final state
//不同动作、监听、回调、最终状态组织起来的一个数组，将用它生成三组事件监听方法
[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
[ "notify", "progress", jQuery.Callbacks("memory") ]
],
state = "pending",
// 返回当前的执行状态
promise = {
state: function() {
return state;
},
// 不管执行状态是resolve还是reject，都执行回调。
always: function() {
// deferred是在该回调函数中定义的一个对象（后面），它将作为返回值被返回，大部分方法将被绑定在该对象中
deferred.done( arguments ).fail( arguments );
return this;
},
// 参数可传入三个函数，第一个是成功的回调，第二个是失败的回调，第三个。。呃。。
// 这个方法有些迷惑。。
then: function( /* fnDone, fnFail, fnProgress */ ) {
var fns = arguments;
// 递归调用jQuery.Deferred()方法，并传入func。这些func将被加入回调列表中
return jQuery.Deferred(function( newDefer ) {
jQuery.each( tuples, function( i, tuple ) {
var action = tuple[ 0 ],
//判断参数是不是函数，如果是就赋值给fn，第一参数对应done，第二个参数对应fail，。。。
fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
deferred[ tuple[1] ](function() {
//这里的this指，调用done、fail的对象，arguments指调用时传入的参数，比如函数。
var returned = fn && fn.apply( this, arguments );
if ( returned && jQuery.isFunction( returned.promise ) ) {
returned.promise()
.done( newDefer.resolve )
.fail( newDefer.reject )
.progress( newDefer.notify );
} else {
newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
}
});
});
fns = null;
}).promise();
},
// 提供一个方法将promise对象扩展到obj对象上。如果没有obj对象，则直接返回promise对象。
promise: function( obj ) {
return obj != null ? jQuery.extend( obj, promise ) : promise;
}
},
// 所有封装的方法都会绑定到该对象上返回
deferred = {};
//为了向后兼容，以前都是用promise.pipe？
promise.pipe = promise.then;
// 遍历之前定义的动作、监听、回调、最终状态组成的数组，进行初始化操作
jQuery.each( tuples, function( i, tuple ) {
// 取得数组当中的 jQuery.Callbacks("once memory")，并将执行结果赋值给list。
var list = tuple[ 2 ],
//取出数组中的表示最终状态的字符串 “resolved rejected”
stateString = tuple[ 3 ];
//将list，也就是jQuery.Callback()方法返回的self对象中的add方法，绑定到promise.resolve/reject/notify上
promise[ tuple[1] ] = list.add;
// 如果stateString有值，以为数组中的第三个小数组中是没有最终状态值的，所以需要if做判断
if ( stateString ) {
// 调用Callbask返回的对象中的add方法，向回调列表中增加三个回调方法：一个匿名函数（改变最终状态），一个disable，一个lock
list.add(function() {
// state = [ resolved | rejected ]
state = stateString;
// [ reject_list | resolve_list ].disable; progress_list.lock
}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
}
//将resolve()、reject()、notify()方法绑定到deferred对象上并暴露出来提供给用户调用
deferred[ tuple[0] ] = function() {
//调用deferred.resovleWith/rejectWith/notifyWith方法，这些方法是在下面定义的
deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
return this;
};
//将jQuery.Callback()方法返回的self对象中的fireWith方法绑定到deferred.resovleWith/rejectWith/notifyWith上
deferred[ tuple[0] + "With" ] = list.fireWith;
});
// 将promise对象所有的方法和属性扩展到deferred对象上，使之具有promise所具有的方法和属性，但promise中并不会包含一些不想暴露的方法，所以使用时，可以返回deferred.promise对象
promise.promise( deferred );
//如果有传入的func，则在deferred对象执行环境执行func，支持另外一种使用Deferred的方法。例如：$.Deferred( function(){} );
if ( func ) {
func.call( deferred, deferred );
}
// 返回deferred对象
return deferred;
},
//多个方法全都执行完毕后，执行回调函数
when: function( subordinate /* , ..., subordinateN */ ) {
......
}
});