本系列文章讲介绍这个Deferred东西到底拿来干什么，从1.5版本加进来，jQuery的很多代码都重写了。直接先上源码分析了，清楚了源码分析，下节将讲具体的应用 以及应用场景。
创建对象 var def=$.Deferred(); 包含 done,resolve,resolveWith,reject,rejectWith,isResolved等等方法
这套系列文章主要是分析jQuery的源码
jQuery.extend({
// Create a simple deferred (one callbacks list)
_Deferred: function () {
var // callbacks list
callbacks = [],
//储存上下文环境和函数参数 stored [ context , args ]
fired,
//避免函数提前触发
firing,
//标示这个延迟对象是否被取消了 cancel方法
cancelled,
// the deferred itself
deferred = {
/*把要依次处理的函数(arguments)[可以是函数列表,也可以是函数数组]加入到队列表(callbacks)中,,返回 deferred 对象
*/
done: function () {
if (!cancelled) {
//arguments函数参数对象,可以看出jQuery喜欢把一个函数所有的参数定义到头部
var args = arguments,
i,
length,
elem,
type,
_fired;
//如果这个延迟对象已经触发，用 _fired保存[context , args ]
if (fired) {
_fired = fired;
fired = 0; //修改fired=0,以便以后继续调用done()函数
}
for (i = 0, length = args.length; i < length; i++) {
elem = args[i];
//这里调用了静态的$.type方法
type = jQuery.type(elem);
//do([f1,f2]),继续回头调用这个方法
if (type === "array") {
deferred.done.apply(deferred, elem);
} else if (type === "function") {
//callbacks 函数集合
callbacks.push(elem);
}
}
//如果这个延迟对象已触发，立即调用resolveWith方法
if (_fired) {
deferred.resolveWith(_fired[0], _fired[1]);
}
}
return this;
},
/*在给定的上下文(context默认为deferred=this对象)中执行队列,清除队列 resolve 执行队列,返回 deferred 对象
*/
resolveWith: function (context, args) {
//没有被取消&&没有被已经触发&&避免提前触发
if (!cancelled && !fired && !firing) {
// make sure args are available (#8421)
args = args || [];
//阻止callbacks提前触发
firing = 1;
try {
//循环执行回调函数队列，不错的写法
while (callbacks[0]) {
callbacks.shift().apply(context, args);
}
}
finally {
//修改deferred里的变量状态,firing=0 阻止回调函数触发,fired store[context,args]
//其实这里的fired firing相当于deferred对象的私有变量，通过改变他的值判断函数队列的执行。
fired = [context, args];
firing = 0;
}
}
return this;
},
/* resolve with this as context and given arguments,这里的this指代deferred对象
*/
resolve: function () {
//当resolve后，以后done（）进来的函数都会立即执行，这个在$(function(){});运用的非常好！这里$(function(){})=
$(document).ready(function(){})原因可以在init实例化的函数中看到
if (jQuery.isFunction(selector)) {return rootjQuery.ready(selector)};
deferred.resolveWith(this, arguments);
return this;
},
/* Has this deferred been resolved?为什么要用!!了,这样才能返回true或者false,比如!!1 !!0 通过deferred对象私有变量判断是否已被
resolved
*/
isResolved: function () {
return !!(firing || fired);
},
// Cancel cancelled=1可以阻止callbacks触发,并清空callbacks.这个函数其实我们自己用不到jQuery后面扩展我们使用的Deferred对象时候会取消掉
cancel: function () {
cancelled = 1;
callbacks = [];
return this;
}
};
return deferred;
},
/*这个$.Deferred()才是给我们使用的，然后根据私有的_Deferred对象扩展出fail，reject等等，这个其实跟done,resolve是同理的，所有作者这里进行了代码公用，只是取了个不同的名字
*/
Deferred: function (func) {
//建立两个私有的延迟对象,扩展deferred，用failDeferred去代替fail ,rejectWith ,reject
var deferred = jQuery._Deferred(),
failDeferred = jQuery._Deferred(),
promise;
//增加错误的deferred methods,and promise
jQuery.extend(deferred, {
//两个参数，一个成功回调函数队列，一个失败回调函数队列
then: function (doneCallbacks, failCallbacks) {
deferred.done(doneCallbacks).fail(failCallbacks);
return this;
},
//不管失败与否都调用
always: function () {
// done的上下文设置为deferred，fail的上下文设置为this
// done和fail的上下文不一致吗？一致！在这里this等于deferred
//这行代码同 deferred.done(arguments).fail(arguments);这里感觉有点怪，为了让这个函数队列arguments执行，不得不在done和fail队列同时添加一种回调函数队列然后 return this;但是后面后删除done队列或者fail队列，看那个函数被执行了 答案在这deferred.done(failDeferred.cancel).fail(deferred.cancel);
return deferred.done.apply(deferred, arguments).fail.apply(this, arguments);
},
//这几个方法跟上面done,resolveWith,resolve,isResolve的同理
fail: failDeferred.done,
rejectWith: failDeferred.resolveWith,
reject: failDeferred.resolve,
isRejected: failDeferred.isResolved,
pipe: function (fnDone, fnFail) {
//暂时没搞懂这个拿来干什么,直到怎么理解的可以留下言谢谢
return jQuery.Deferred(function (newDefer) {
//遍历一个对象
jQuery.each({
done: [fnDone, "resolve"],
fail: [fnFail, "reject"]
}, function (handler, data) {
var fn = data[0],
action = data[1],
returned;
if (jQuery.isFunction(fn)) {
deferred[handler](function () {
returned = fn.apply(this, arguments);
if (returned && jQuery.isFunction(returned.promise)) {
returned.promise().then(newDefer.resolve, newDefer.reject);
} else {
newDefer[action + "With"](this === deferred ? newDefer : this, [returned]);
}
});
} else {
deferred[handler](newDefer[action]);
}
});
}).promise();
},
/* 返回一个包含 done fail isResolved isRejected promise then always pipe的deferred对象，不让外部修改状态，只能读状态
*/
promise: function (obj) {
if (obj == null) {
if (promise) {
return promise;
}
promise = obj = {};
}
var i = promiseMethods.length;
//又一个经典的循环方法，这样更快，这样i--是跟0比较，而不用跟promiseMethods.length比较,学到吧
while (i--) {
obj[promiseMethods[i]] = deferred[promiseMethods[i]];
}
return obj;
}
});
// 成功队列执行完成后，会执行失败带列的取消方法
// 失败队列执行完成后，会执行成功队列的取消方法
// 确保只有一个函数队列会被执行，即要么执行成功队列，要么执行失败队列；
// 即状态只能是或成功、或失败，无交叉调用
deferred.done(failDeferred.cancel).fail(deferred.cancel);
// Unexpose cancel
delete deferred.cancel;
//如果有函数传进来则立即执行 传入deferred对象,调用回调函数,如def=$.Deferred(funciton(defer){ defer.resolve;.. })
if (func) {
func.call(deferred, deferred);
}
//返回deferred对象
return deferred;
},
/* Deferred helper
异步队列工具函数
firstParam：一个或多个Deferred对象或JavaScript普通对象
*/
when: function (firstParam) {
//如果参数的长度等于1，并且存在promise函数，表面是一个deferred对象，它这样判断传入的参数是个deferred对象。如果都不满足则新建一个$.Deferred()对象
var args = arguments,
i = 0,
length = args.length,
count = length,
deferred = length <= 1 && firstParam && jQuery.isFunction(firstParam.promise) ?
firstParam :
jQuery.Deferred();
// 构造成功（resolve）回调函数
function resolveFunc(i) {
return function (value) {
// 如果传入的参数大于一个，则将传入的参数转换为真正的数组 sliceDeferred=[].slice
args[i] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
//直到count为0的时候
if (!(--count)) {
// Strange bug in FF4:
// Values changed onto the arguments object sometimes end up as undefined values
// outside the $.when method. Cloning the object into a fresh array solves the issue
//resolve deferred 响应这个deferred对象，上面这句话好像是解决一个奇怪的bug
deferred.resolveWith(deferred, sliceDeferred.call(args, 0));
}
};
}
if (length > 1) {
for (; i < length; i++) {
//存在agrs[i]并且是args[i]是deferred对象，那这样的话作者怎么不直接jQuery.isFunction(args[i].promise)，感觉多判断了，作者也蒙了吧
if (args[i] && jQuery.isFunction(args[i].promise)) {
//执行一次resolveFunc(i)count就减少一个
args[i].promise().then(resolveFunc(i), deferred.reject);
} else {
// 计数器，表示发现不是Deferred对象，而是普通JavaScript象 ,反正最后只要count==0才能resovle deferred
--count;
}
}
if (!count) {
deferred.resolveWith(deferred, args);
}
} else if (deferred !== firstParam) { //如果只传了一个参数，而这个参数又不是deferred对象，则立即resolve
deferred.resolveWith(deferred, length ? [firstParam] : []);
}
return deferred.promise(); //返回deferred只读视图
}
});