第三十三课：jQuery Deferred详解1

之前我们讲了Mochikit Deferred，JSDeferred，现在讲jQuery Deferred。首先，我们先来讲下他们的区别：

在保存回调函数时，Mochikit Deferred（dojo Deferred）是用一个2维数组保存的，里面的小数组只有两项，一个是成功回调的函数，一个是失败回调的函数。

JSDeferred则每个实例都必有ng,ok这两个回调函数。

jQuery Deferred则一个_Deferred负责添加成功回调，一个负责添加错误回调。

它们的API区别如下图：

接下来，我们来看一下jQuery1.51的源码：

此版本jQuery的Deferred对象的实现，是使用了一个双链结构，每条链都由_Deferred方法返回的deferred对象实现。

var promiseMethods = "then done fail isResolved isRejected promise".split(" "),

　　sliceDeferred = [].slice;

jQuery.extend({

　　_Deferred: function(){   //jQuery的静态方法，在Deferred中被调用，请先看Deferred方法。

　　　　var callbacks = [], fired, firing,cancelled,

　　　　　　deferred = {   //调用jQuery._Deferred()方法，返回的对象

　　　　　　　　done:function(){    //根据下面的例子：var cb = $.Deferred();done方法中传入的参数是failDeferred.cancel，其实就是deferred.cancel。

　　　　　　　　　　if(!cancelled){    //如果没有被取消，就进入if语句，刚开始是undefined，取非，所以是true，进入if语句。

　　　　　　　　　　　　var args = arguments, i , length, elem, type, _fired;

　　　　　　　　　　　　if(fired){   //刚开始是undefined，不进入if语句。

　　　　　　　　　　　　　　_fired = fired;

　　　　　　　　　　　　　　fired = 0;

　　　　　　　　　　　　}

　　　　　　　　　　　　for(i=0,length = args.length ;i<length; i++){   //把传入done方法的参数遍历，这里就是failDeferred.cancel

　　　　　　　　　　　　　　elem = args[i];

　　　　　　　　　　　　　　type = jQuery.type(elem);     //判断每一个参数的类型

　　　　　　　　　　　　　　if(type === "array"){   //如果是数组，就重新调用deferred.done方法。

　　　　　　　　　　　　　　　　deferred.done.apply(deferred,elem);

　　　　　　　　　　　　　　}else if(type === "function"){   //如果参数的类型是函数，就把函数添加到callbacks数组中。这里的failDeferred.cancel是函数，所以执行这里。

　　　　　　　　　　　　　　　　callbacks.push(elem);   //这时callbacks = [failDeferred.cancel]

　　　　　　　　　　　　　　}

　　　　　　　　　　　　}

　　　　　　　　　　　　if(_fired){    //undefined，不进入if语句。

　　　　　　　　　　　　　　deferred.resolveWith(_fired[0], _fired[1]);

　　　　　　　　　　　　}

　　　　　　　　　　}

　　　　　　　　　　return this;   //this就是调用done方法的对象

　　　　　　　　},

　　　　　　　　resolveWith:function(context ,args){

　　　　　　　　　　if(!cancelled && !fired && !firing){  //根据例子来讲解的，如果没取消，也没触发，也没在触发中，那么就进入if语句进行触发。

　　　　　　　　　　　　args = args || [];

　　　　　　　　　　　　firing = 1;     //改变状态，使这个Deferred处于触发中状态

　　　　　　　　　　　　try{

　　　　　　　　　　　　　　while(callbacks[0]){    //callbacks = [failDeferred.cancel , fun1]

　　　　　　　　　　　　　　　　callbacks.shift().apply(context, args); //shift方法，把数组的第一项删除，并返回第一项。这里执行failDeferred.cancel方法。因为调用了apply方法，其实就是在cb的执行上下文中执行failDeferred.cancel方法。但是由于在cancel方法中，不是针对this操作，而是针对私有变量callbacks操作，因此执行failDeferred.cancel方法时操作的还是failDeferred对象中的callbacks。所以这时，failDeferred对象中的私有变量callbacks = [deferred（局部）的cancel]会变成[]。这意味着cb延迟对象触发了resolve方法（成功触发）。这时cb的callbacks = [ fun1]，然后继续循环，取出fun1，执行。然后cb和failDeferred的callbacks数组都成为[]。

　　　　　　　　　　　　　　}

　　　　　　　　　　　　}finally{

　　　　　　　　　　　　　　fired = [context, args];

　　　　　　　　　　　　　　firing = 0;

　　　　　　　　　　　　}

　　　　　　　　　　}

　　　　　　　　　　return this;

　　　　　　　　},

　　　　　　　　resolve:function(){

　　　　　　　　　　deferred.resolveWith(this, arguments);   //resolve方法其实就是执行resolveWith方法,这里的deferred其实就是cb。因为执行var cb = $.Deferred()时，cb引用了deferred对象，callbacks等属性。所以这些变量和属性都会保存在内存中，因此你调用cb.resolve时，执行的deferred的方法，其实就是cb的resolveWith方法。而里面的callbacks属性就是cb对象的callbacks属性。

　　　　　　　　　　return this;

　　　　　　　　},

　　　　　　　　isResolved:function(){

　　　　　　　　　　return !!(firing || fired);

　　　　　　　　},

　　　　　　　　cancel:function(){

　　　　　　　　　　cancelled = 1;

　　　　　　　　　　callbacks = [];

　　　　　　　　　　return this;

　　　　　　　　}

　　　　　　};

　　　　　　return deferred;

　　},

　　Deferred:function(func){     //也是jQuery的静态方法，它就是jQuery的Deferred。里面有两个jQuery._Deferred()方法返回的deferred对象

　　　　var deferred = jQuery._Deferred(),   //执行jQuery的静态方法，返回一个deferred对象。因为这里的局部变量deferred跟jQuery._Deferred()返回的对象deferred重名，因此我们叫局部变量deferred称为deferred（变量）

　　　　　　failDeferred = jQuery._Deferred(),  //同样返回一个deferred对象。跟上面那个deferred对象不是同一个，但是具有相同的方法和属性。

　　　　　　　　promise;

　　　　jQuery.extend(deferred,{    //扩展deferred变量引用的deferred对象，而不是failDeferred引用的deferred对象。deferred对象默认有done，resolveWith，resolve，isResolved，cancel五个方法。deferred（变量）对象扩展后，又增加了then,fail,rejectWith,reject,isRejected,promise等六个方法。

　　　　　　then : function(doneCallbacks , failCallbacks){

　　　　　　 　　deferred.done(doneCallbacks).fail(failCallbacks);

　　　　　　　　 return this;

　　　　　　},

　　　　　　fail:failDeferred.done,   //当deferred（变量）对象调用fail方法添加失败回调函数时，其实调用的是代表失败的failDeferred对象done方法。

　　　　　　rejectWith:failDeferred.resolveWith,

　　　　　　reject:failDeferred.resolve,   //当deferred（变量）对象触发失败回调方法时，也就是触发fail方法添加的回调函数时，就会调用代表失败的failDeferred对象的resolve方法，而这个方法会执行failDeferred对象中通过done方法添加的回调函数。这样就实现了Deferred对象的成功回调和失败回调的操作（内部通过两个链，一个链代表成功回调，一个链代表失败回调）。也就是说，失败回调交给failDeferred对象处理，成功回调交给deferred（变量）对象自己处理，这个deferred（变量）对象就是$.Deferred()返回的对象。

　　　　　　isRejected:failDeferred.isResolved,

　　　　　　promise:function(obj){    //这是一个单例方法，无论调用多少次这个promise方法，都只会返回同一个对象。

　　　　　　　　if(obj == null){

　　　　　　　　　　if(promise){

　　　　　　　　　　　　return promise;

　　　　　　　　　　}

　　　　　　　　　　promise = obj = {};

　　　　　　　　}

　　　　　　　　var i = promiseMethods.length;

　　　　　　　　while(i--){

　　　　　　　　　　obj[promiseMethods[i]] = deferred[promiseMethods[i]];    //Promise对象有then，done，fail，isResolved，isRejected，promise六个方法，它没有触发回调的方法，因此Promise对象只能添加回调方法，不能触发回调方法的执行。

　　　　　　　　}

　　　　　　　　return obj;

　　　　　　}

　　　　});

　　　　deferred.done(failDeferred.cancel).fail(deferred.cancel);  //调用deferred（变量）的done方法和fail方法。我们去看一下这两个方法，请去看_Deferred()。当执行完done方法后，deferred（变量）对象中的私有变量callbacks = [failDeferred.cancel]，返回deferred（变量），再调用它的fail方法。它的fail方法是failDeferred.done方法。而failDeferred.done方法就是deferred对象的done方法，传入的参数是deferred（变量）cancel方法。执行完deferred（变量）的fail方法后，deferred（变量）对象中的私有变量callbacks = [failDeferred.cancel]。而failDeferred对象中的私有变量callbacks = [deferred（局部）的cancel]。

　　　　delete deferred.cancel;   //删除deferred（局部）的cancel方法。

　　　　if(func){

　　　　　　func.call(deferred,deferred);   //举个例子：如果在var cb = $.Deferred();中传入了一个函数func，那么就会在deferred（局部）对象的执行上下文中执行这个函数，并且把此对象作为参数传给函数func。

　　　　}

　　　　return deferred;   //返回deferred（局部）对象。

　　},

　　when:function(firstParam){

　　　　var args = arguments, i =0, length = args.length, count = length;

　　　　var deferred = length <=1 && firstParam && jQuery.isFunction(firstParam.promise) ? firstParam : jQuery.Deferred();  //如果只传入了一个Deferred或Promise对象。，就直接使用此对象，否则生成一个新的Deferred对象。

　　　　function resolveFunc(i){   //定义私有函数

　　　　　　return function(value){

　　　　　　　　args[i] = arguments.length > 1 ? sliceDeferred.call(arguments, 0 ) : value;   //sliceDeferred就是[].slice方法。args[0]是cb1.resolve()传入的参数值，args[1]是cb2.resolve()传入的参数值。

　　　　　　　　if(!(--count)){   //如果传入when中的所有Deferred都触发了resolve方法，这里的count才会变成0，因此为真，触发cb3的resolve方法。

　　　　　　　　　　deferred.resolveWith(deferred,sliceDeferred.call(args,0));

　　　　　　　　}

　　　　　　}

　　　　}

　　　　if(length > 1){    //如果传入了2个以及2个以上的Deferred对象

　　　　　　for(; i < length ;i++){

　　　　　　　　if(args[i] && jQuery.isFunction(args[i].promise)){  //如果传入的参数是Deferred对象

　　　　　　　　　　args[i].promise().then(resolveFunc(i), deferred.reject);   //取到Deferred的Promise对象，调用它的then方法。then方法是：function(doneCallbacks , failCallbacks){ deferred.done(doneCallbacks).fail(failCallbacks); return this; },then方法可以同时添加成功回调和失败回调。这里举个例子：var cb1 = $.Deferred(); var cb2 = $.Deferred();    var cb3 = $.when(cb1 , cb2).done( function fun3(){ cb1和cb2都触发成功了 } );  cb1的成功回调数组callbacks=[resolveFunc[0]]，失败的回调数组callbacks=[cb3.reject]，cb2的成功回调数组callbacks=[resolveFunc[1]]，失败的回调数组callbacks=[cb3.reject],cb3的成功回调数组为callbacks = [fun3]。这时，如果你触发cb1和cb2的resolve方法，那么就会触发cb3的resolve方法。如果你只触发了cb1或cb2中的其中一个resolve方法，那么cb3的resolve方法不会触发，需要等cb1和cb2的resolve方法都触发了，才会触发。如果你触发了cb1或cb2中任何一个reject方法，那么cb3的reject方法就会触发。

　　　　　　　　}else{

　　　　　　　　　　--count;  //如果传入的都不是Deferred对象，这里的count就会减为0.如果有一个，就不会等于0.

　　　　　　　　}

　　　　　　}

　　　　　　if(!count){     //如果为0，就会执行这个方法。举个例子：$.when("chaojidan"，"chaojidan1"，"chaojidan2")

　　　　　　　　deferred.resolveWith(deferred,args);

　　　　　　}

　　　　}else if(deferred !== firstParam){       //如果没传入Deferred对象，或者传入了一个不是Deferred对象的参数。举个例子：var cb = $.when()或$.when("chaojidan")

　　　　　　　　deferred.resolveWith(deferred,length?[firstParam] : [] );

　　　　}

　　　　return deferred.promise();   //如果传入了一个Deferred对象，就直接返回它的Promise对象。举个例子：var cb = $.Deferred();var cb1 = $.when(cb)，这时的cb1其实是cb的Promise对象。其他情况，都返回一个新的Deferred的Promise对象。

　　}

})

此段代码，我们根据这个例子：var cb = $.Deferred();cb.done(function fun1(){alert(1)}),cb.resolve();来讲解。从上可知，当调用了var cb = $.Deferred();方法后，cb的callbacks=[failDeferred.cancel]，failDeferred对象中的私有变量callbacks = [cb.cancel]，当调用cb.done(function fun1(){alert(1)})方法之后，cb的callbacks=[failDeferred.cancel , fun1]，failDeferred不变，当调用cb.resolve();方法后，其实就是调用deferred.resolveWith(cb, []);请看此方法解释。最终，cb和failDeferred的私有变量callbacks都会变成[]。

这是jQuery的第一代的Deferred模块，在jQuery1.6，1.7，1.8中，都进行优化，下节课讲解。

加油！