jQuery的开发速度很快，几乎每半年一个大版本，每两个月一个小版本。

每个版本都会引入一些新功能。今天我想介绍的，就是从jQuery 1.5.0版本开始引入的一个新功能—- deferred对象。

这个功能很重要，未来将成为jQuery的核心方法，它彻底改变了如何在jQuery中使用ajax。

为了实现它，jQuery的全部ajax代码都被改写了。

但是，它比较抽象，初学者很难掌握，网上的教程也不多。所以，我把自己的学习笔记整理出来了，希望对大家有用。

本文不是初级教程，针对的读者是那些已经具备jQuery使用经验的开发者。

---

jQuery的deferred对象详解

一、什么是deferred对象？

开发网站的过程中，我们经常遇到某些耗时很长的javascript操作。其中，既有异步的操作（比如ajax读取服务器数据），也有同步的操作（比如遍历一个大型数组），它们都不是立即能得到结果的。

通常的做法是，为它们指定回调函数（callback）。即事先规定，一旦它们运行结束，应该调用哪些函数。

但是，在回调函数方面，jQuery的功能非常弱。为了改变这一点，jQuery开发团队就设计了deferred对象。

简单说，deferred对象就是jQuery的回调函数解决方案。在英语中，defer的意思是”延迟”，所以deferred对象的含义就是”延迟”到未来某个点再执行。

它解决了如何处理耗时操作的问题，对那些操作提供了更好的控制，以及统一的编程接口。它的主要功能，可以归结为四点。下面我们通过示例代码，一步步来学习。

二、ajax操作的链式写法

首先，回顾一下jQuery的ajax操作的传统写法：

$.ajax({    url : "test.html",    success : function() {        info_o_success(1);    },    error : function() {        info_o_error(1);    }});

在上面的代码中，$.ajax()接受一个对象参数，这个对象包含两个方法：success方法指定操作成功后的回调函数，error方法指定操作失败后的回调函数。

$.ajax()操作完成后，如果使用的是低于1.5.0版本的jQuery，返回的是XHR对象，你没法进行链式操作；如果高于1.5.0版本，返回的是deferred对象，可以进行链式操作。

现在，新的写法是这样的：

$.ajax("test.html")    .done(function() {        info_n_success(1);    })    .fail(function() {        info_n_error(1);    });

可以看到，done()相当于success方法，fail()相当于error方法。采用链式写法以后，代码的可读性大大提高。

三、指定同一操作的多个回调函数

deferred对象的一大好处，就是它允许你自由添加多个回调函数。

还是以上面的代码为例，如果ajax操作成功后，除了原来的回调函数，我还想再运行一个回调函数，怎么办？

很简单，直接把它加在后面就行了。

$.ajax("test.html")    .done(function() {        info_n_success(21);    })    .fail(function() {        info_n_error(2);    })    .done(function() {        info_n_function(22);    });

回调函数可以添加任意多个，它们按照添加顺序执行。

四、为多个操作指定回调函数

deferred对象的另一大好处，就是它允许你为多个事件指定一个回调函数，这是传统写法做不到的。

请看下面的代码，它用到了一个新的方法$.when()：

$.when($.ajax("test1.html"), $.ajax("test2.html"))    .done(function() {        info_n_success(3);    })    .fail(function() {        info_n_error(3);    });

这段代码的意思是，先执行两个操作$.ajax(“test1.html”)和$.ajax(“test2.html”)，如果都成功了，就运行done()指定的回调函数；

如果有一个失败或都失败了，就执行fail()指定的回调函数。

五、普通操作的回调函数接口（上）

deferred对象的最大优点，就是它把这一套回调函数接口，从ajax操作扩展到了所有操作。也就是说，任何一个操作不管是ajax操作还是本地操作，也不管是异步操作还是同步操作都可以使用deferred对象的各种方法，指定回调函数。

我们来看一个具体的例子。假定有一个很耗时的操作wait：

var wait4 = function() {    var tasks = function() {        log("new-4-methord completed!");    };    setTimeout(tasks, 5000);};

我们为它指定回调函数，应该怎么做呢？

很自然的，你会想到，可以使用$.when()：

$.when(wait4())    .done(function() {        info_n_success(4+"-right now");    })    .fail(function() {        info_n_error(4);    });

但是，这样写的话，done()方法会立即执行，起不到回调函数的作用。原因在于$.when()的参数只能是deferred对象，所以必须对wait()进行改写：

var dtd5 = $.Deferred(); // 新建一个Deferred对象    var wait5 = function(dtd5) {        var tasks = function() {            log("new-5-methord completed!");            dtd5.resolve();//改变Deferred对象的执行状态        };        setTimeout(tasks, 5000);        return dtd5;};

现在，wait()函数返回的是Deferred对象，这就可以加上链式操作了。

$.when(wait5(dtd5))    .done(function() {        info_n_success(5+'-wait for methord complate');    })    .fail(function() {        info_n_error(5);    });

wait()函数运行完，就会自动运行done()方法指定的回调函数。

六、deferred.resolve()方法和deferred.reject()方法

如果仔细看，你会发现在上面的wait()函数中，还有一个地方我没讲解。那就是dtd.resolve()的作用是什么？

要说清楚这个问题，就要引入一个新概念执行状态。jQuery规定，deferred对象有三种执行状态

• 未完成 如果执行状态是”未完成”，则继续等待，或者调用progress()方法指定的回调函数（jQuery1.7版本添加）
• 已完成 如果执行状态是”已完成”（resolved）,deferred对象立刻调用done()方法指定的回调函数
• 已失败 如果执行状态是”已失败”，调用fail()方法指定的回调函数

前面部分的ajax操作时，deferred对象会根据返回结果，自动改变自身的执行状态；但是，在wait()函数中，这个执行状态必须由程序员手动指定。

dtd.resolve()的意思是，将dtd对象的执行状态从”未完成”改为”已完成”，从而触发done()方法。

类似的，还存在一个deferred.reject()方法，作用是将dtd对象的执行状态从”未完成”改为”已失败”，从而触发fail()方法。

var dtd52 = $.Deferred(); // 新建一个Deferred对象    var wait52 = function(dtd52) {        var tasks = function() {            log("new-52-methord completed!");            dtd52.reject();//改变Deferred对象的执行状态        };        setTimeout(tasks, 5000);        return dtd52;    };$.when(wait52(dtd52))    .done(function() {        info_n_success(52+'-wait for methord complate');    })    .fail(function() {        info_n_error(52+'-in here!');    });

七、deferred.promise()方法

上面这种写法，还是有问题。那就是dtd是一个全局对象，所以它的执行状态可以从外部改变。

请看下面的代码：

var dtd6 = $.Deferred(); // 新建一个Deferred对象    var wait6 = function(dtd6) {        var tasks = function() {            log("new-6-methord completed!");            dtd6.resolve();//改变Deferred对象的执行状态        };        setTimeout(tasks, 5000);        return dtd6;    };$.when(wait6(dtd6))    .done(function() {        info_n_success(6 + '-when use ‘dtd.resolve()’ bllow,right now complate');    })    .fail(function() {        info_n_error(6);    });dtd6.resolve();

我在代码的尾部加了一行dtd.resolve()，这就改变了dtd对象的执行状态，因此导致done()方法立刻执行，打印”success”的日志记录，等5秒之后再打印出”complate”的日志记录。

为了避免这种情况，jQuery提供了deferred.promise()方法。

它的作用是，在原来的deferred对象上返回另一个deferred对象，后者只开放与改变执行状态无关的方法（比如done()方法和fail()方法），屏蔽与改变执行状态有关的方法（比如resolve()方法和reject()方法），从而使得执行状态不能被改变。

请看下面的代码：

var dtd7 = $.Deferred();//新建一个Deferred对象    var wait7 = function(dtd){        var tasks = function(){            log("new-7-methord completed!");            dtd.resolve();//改变Deferred对象的执行状态        };        setTimeout(tasks,5000);        return dtd.promise();//返回promise对象    };var d7 = wait7(dtd7); // 新建一个d对象，改为对这个对象进行操作$.when(d7)    .done(function() {        info_n_success(7+'-wait for methord complate');    })    .fail(function() {        info_n_error(7);    });//d.resolve(); // 此时，这个语句是无效的

在上面的这段代码中，wait()函数返回的是promise对象。然后，我们把回调函数绑定在这个对象上面，而不是原来的deferred对象上面。这样的好处是，无法改变这个对象的执行状态，要想改变执行状态，只能操作原来的deferred对象。

不过，更好的写法是将dtd对象变成wait()函数的内部对象。

var wait8 = function(){    var dtd = $.Deferred();//在函数内部，新建一个Deferred对象    var tasks = function(){        log("new-8-methord completed!");        dtd.resolve();//改变Deferred对象的执行状态    }    setTimeout(tasks,5000);    return dtd.promise(); // 返回promise对象};$.when(wait8())    .done(function() {        info_n_success(8 + '-wait for methord complate');    })    .fail(function() {        info_n_error(8);    });

八、普通操作的回调函数接口（中）

另一种防止执行状态被外部改变的方法，是使用deferred对象的建构函数$.Deferred()。

这时，wait函数还是保持不变，我们直接把它传入$.Deferred()：

$.Deferred(wait9)    .done(function() {        info_n_success(9+'-wait for methord complate');    })    .fail(function() {        info_n_error(9);    });var wait9 = function(){    var dtd = $.Deferred();//在函数内部，新建一个Deferred对象    var tasks = function(){        log("new-9-methord completed!");        dtd.resolve();//改变Deferred对象的执行状态    }    setTimeout(tasks,5000);    return dtd.promise(); // 返回promise对象};

jQuery规定，$.Deferred()可以接受一个函数名（注意，是函数名）作为参数，$.Deferred()所生成的deferred对象将作为这个函数的默认参数。

九、普通操作的回调函数接口（下）

除了上面两种方法以外，我们还可以直接在wait对象上部署deferred接口。

var dtd10 = $.Deferred(); // 生成Deferred对象var wait10 = function(dtd10) {    var tasks = function() {        log("new-10-methord completed!");        dtd10.resolve(); // 改变Deferred对象的执行状态    };    setTimeout(tasks, 5000);};dtd10.promise(wait10);wait10.done(function() {    info_n_success(10 + '-wait for methord complate');}).fail(function() {    info_n_error(10);});wait10(dtd10);

这里的关键是dtd.promise(wait10)这一行，它的作用就是在wait对象上部署Deferred接口。

正是因为有了这一行，后面才能直接在wait上面调用done()和fail()。

十、小结：deferred对象的方法

前面已经讲到了deferred对象的多种方法，下面做一个总结：

（1） $.Deferred() 生成一个deferred对象。
（2） deferred.done() 指定操作成功时的回调函数
（3） deferred.fail() 指定操作失败时的回调函数
（4） deferred.promise() 没有参数时，返回一个新的deferred对象，该对象的运行状态无法被改变；接受参数时，作用为在参数对象上部署deferred接口。
（5） deferred.resolve() 手动改变deferred对象的运行状态为”已完成”，从而立即触发done()方法。
（6） deferred.reject() 这个方法与deferred.resolve()正好相反，调用后将deferred对象的运行状态变为”已失败”，从而立即触发fail()方法。
（7） $.when() 为多个操作指定回调函数。

除了这些方法以外，deferred对象还有二个重要方法，上面的教程中没有涉及到。

（8） deferred.then()
（9） deferred.always()

有时为了省事，可以把done()和fail()合在一起写，这就是then()方法。

$.when($.ajax("test11.html"))    .then(function() {        log("new-11-success");    }, function() {        log('new-11-error');    });

如果then()有两个参数，那么第一个参数是done()方法的回调函数，第二个参数是fail()方法的回调方法。如果then()只有一个参数，那么等同于done()。

deferred.always()
这个方法也是用来指定回调函数的，它的作用是，不管调用的是deferred.resolve()还是deferred.reject()，最后总是执行。

$.ajax("test12.html")    .always(function() {        log("new-12-methord completed!");    });

---

这里源码参考

---

详解Angular.js的$q.defer()服务异步处理

什么是defer？

$q是Angular的一种内置服务，它可以使你异步地执行函数，并且当函数执行完成时或异常时它允许你使用函数的返回值或返回执行状态通知等。
defer的意思是延迟，$q.defer() 可以创建一个deferred延迟对象实例，实例旨在暴露派生的Promise 实例，Promise就是一种对执行结果不确定的一种预先定义，如果成功，就xx；如果失败，就xx，就像事先给出了一些承诺。

用法

一个最完整的写法：

var defer1 = $q.defer();function fun() { var deferred = $q.defer(); $timeout(function () {  deferred.notify("notify");  if (iWantResolve) {   deferred.resolve("resolved");  } else {   deferred.reject("reject");  } }, 500); return deferred.promise;}$q.when(fun())  .then(function(success){   console.log("success");   console.log(success);  },function(err){   console.log("error");   console.log(err);  },function(notify){   console.log("notify");   console.log(notify);  })  .catch(function(reson){   console.log("catch");   console.log(reson);  })  .finally(function(final){   console.log('finally');   console.log(final);  });

1. 通过$q服务注册一个延迟对象

var deferred=$q.defer();

2. 成功解决(resolve)了其派生的promise

参数value将来会被用作successCallback(success){}函数的参数value。

deferred.resolve(success)

3. 未成功解决其派生的promise

参数reason被用来说明未成功的原因。此时deferred实例的promise对象将会捕获一个任务未成功执行的错误，promise.catch(errorCallback(reason){…}) 。

deferred.reject(reason)

4. 更新promise的执行状态通知

deferred.notify("notify");

5. 对promise进行处理

$q.when(fun())    .then(function(success){        console.log("success");        console.log(success);    },function(err){        console.log("error");        console.log(err);    },function(notify){        console.log("notify");        console.log(notify);    })    .catch(function(reson){        console.log("catch");        console.log(reson);    })    .finally(function(final){        console.log('finally');        console.log(final);    });

这里一般简写为：

fun().then(successCallback, errorCallback, notifyCallback);

注：

deferred的方法中的参数都返回给了promise与callback的参数都是一一对应的，如：

deferred.resolve(success)的success对应successCallback(success)的success。

angular的$q.all()

$q.all()在多个promise必须执行成功后才能执行成功回调，传递值为数组或哈希值，数组中每个值为与Index对应的promise对象。

这个方法可以将每个promise里的某些重复代码或者判断，只需要在$q.all()的回调处理一次即可，简化了代码与工作量。

写法为：

var iWantResolve = true;//没有实际意思，测试运行resolve或rejectfunction promise1() { return $q(function (resolve, reject) {  $timeout(function () {   if (iWantResolve) {    resolve("promise1 resolved");   } else {    reject("promise1 reject");   }  }, 1000) })}promise1()  .then(function (s1) {//success callback   console.log(s1);  })  .catch(function (err1) {//error callback   console.log(err1);  });function promise2() { var deferred = $q.defer(); $timeout(function () {  deferred.notify("promise2 notify");  if (iWantResolve) {   deferred.resolve("promise2 resolved");  } else {   deferred.reject("promise2 reject");  } }, 500); return deferred.promise;}promise2()  .then(function (s2) {   console.log(s2);  }, function (err2) {   console.log(err2);  });$q.all([promise1(), promise2()])  .then(function (dataArr) {   //promise都成功执行后的回调函数   console.log("$q.all: ", dataArr);  }, function (err) {   console.log("$q.all: ", err)  });

像这个例子，每个promise回调都打印了返回值，那么可以用$q.all()处理在其回调打印dataArr，则包含了所有promise返回值！

---

jquery和angular的deferred用法大致相同，但有两处要注意的地方

• jQuery:
  defer=$.Deferred();
  defer.promise();
• angular:
  var deferred=$q.defer();
  deferred.promise;