>

jQuery的deferred对象使用详解,deferred对象使用详解

- 编辑:www.bifa688.com -

jQuery的deferred对象使用详解,deferred对象使用详解

附Deferred对象的其余措施:

在jquery1.5事后的版本中,加入了四个deferred对象,也正是延迟对象,用来拍卖今后某不时常间点发出的回调函数。同期,还改写了ajax方法,今后的ajax方法重回的是三个deferred对象。
那就来探视deferred对象的用法。
1.ajax的链式回调 

$.Deferred().state(); // 'pending'
$.Deferred().resolve().state(); // 'resolved'
$.Deferred().reject().state(); // 'rejected'

依据上述三个法子的特色,开采:

接者学习,漏了贰个always()方法,参数也是回调函数,与done和fail差别的是,无论任何情形都实行always方法中的回调。
deferred对象不只能够用在jquery的ajax方法中,他提供了一多种的接口,使它的通用型大大进步。
举例说有如此贰个耗费时间可比久的主意

4.怎么样情形下使用deferred对象和Promises?
地点讲了比非常多,那么我们毕竟在哪些处境下选取Deferred对象和Promises对象呢?

deferred.thendeferred.done方法都可以平昔收贰个参数函数,且第一个参数函数都以在deferred对象在resolve时被调用。

很好通晓,唯有当有着异步都成功时,才会实践done方法中的回调,不然会举办fail方法中的回调,一样好理解的是的done方法中回调函数的暗中同意参数数量则和when方法参数数量同样。
而只要when方法中传出的只是常见对象,不是deferred对象时,会即时实践done方法中的回调,回调函数的暗中认可参数为流传when方法的目的自己。

如上正是本文的全部内容,希望对大家的读书抱有支持。

就算如此then方法可改换重临值,但在不记挂回到值且独有一个参数函数的前提下,八个主意真的能够完结平等的遵从。

上述正是本文的全体内容,希望对大家的学习抱有帮忙,也愿意我们多多援助脚本之家。

(4)deferred.resolve(args) and deferred.resolveWith(context [,args]) -- 解决Deferred(延迟)对象,并凭借给定的args参数(resolveWith给定context)调用任何doneCallbacks。

事先看外人的demo,发掘在延迟对象被resolve时要推行的代码,有时会写在deferred.then方法里进行,不时会写在deferred.done方法里实践。

$.when($.ajax('test.json'), $.ajax('demo.json')) .done(function(){
 alert('success'); 
}).fail(function(){
 alert('error');
});

里头success内定ajax操作成功后的回调函数,error钦定ajax操作战败后的回调函数。jQuery1.5版本以前,Ajax操作重返的是贰个XMLHTTPRequest对象,不协助链式操作。1.5本子起初,ajax操作再次来到的是jqXH科雷傲对象,那是二个deferred对象,而deferred对象三个明显的功利正是能够开始展览链式操作,因为deferred对象的兼具办法再次来到的均是deferred对象。

先看一下deferred.done的用法:

var success = function(){
 alert('success'); 
};

var error = function(){
 alert('error');
};

// 两个参数
$.ajax('test.json').then(success, error);

// 一个参数
$.ajax('test.json').then(success);

参数:type(Deferred),二个或五个延迟对象,也许普通的JavaScript对象。

对照,done方法越来越纯粹吗,then方法会更头昏眼花一些,但无法完全替代done方法,使用then方法的话,依然小心些的好。

$.ajax('test.json').done(function(resp){
 // done 相当于success回调,其中默认的参数为success回调的参数
 alert('success');
}).done(function(){
 // do something...
}).done(function(){
 // do something...
});
function asyncEvent() {
   var dfd = jQuery.Deferred();

    // Resolve after a random interval
    setTimeout(function () {
       dfd.resolve("hurray");
    }, Math.floor(400   Math.random() * 2000));

    // Reject after a random interval
    setTimeout(function () {
       dfd.reject("sorry");
    }, Math.floor(400   Math.random() * 2000));

    // Show a "working..." message every half-second
    setTimeout(function working() {
       if (dfd.state() === "pending") {
          dfd.notify("working... ");
           setTimeout(working, 500);
        }
     }, 1);

      // Return the Promise so caller can't change the Deferred
      return dfd.promise();
 }

// Attach a done, fail, and progress handler for the asyncEvent
$.when(asyncEvent()).then(
    function (status) {
       alert(status   ", things are going well");
    },
    function (status) {
       alert(status   ", you fail this time");
    },
    function (status) {
       alert(status);
    }
);
// 创建deferred对象
var dtd = $.Deferred();

// 解决deferred对象
dtd.resolve('finish');
// 调用done方法
dtd.done(doneCallback [, doneCallback])
// 当deferred对象被 resolve 时,执行doneCallback函数
// 参数可为一个函数、多个函数或函数数组
// 返回原来的deferred或promise对象
 // 当传入when方法的参数只是普通对象时
$.when({test: 'test'}).done(function(resp){
 console.log(resp.test); // 'test' 
}).fail(function(){
 // 由于传入的对象不是deferred对象,那么就不会调用fail中的回调了 
}) 
$.when($.ajax({}), $.ajax({}))
  .done(function(){ alert("success!"); })
  .fail(function(){ alert("error!"); });

再看下deferred.then的用法和特点:

function a(){
 var def = $.Deferred(); // 创建deferred对象 
 function b(){
 alert('start');
 def.resolve(); // 改变deferred对象的状态
 } 
 setTimeout(b, 3000); 
 return def.promise();
}

$.when(a().reject()).done(function(){ // reject()方法无效
 alert("It's callback");
});

(2)管理队列

// 创建deferred对象
var dtd = $.Deferred();

// 解决deferred对象
dtd.resolve('finish');

// 调用then方法
deferred.then(doneFilter [, failFilter] [, progressFilter])
// then方法特性:
// 当deferred对象被resolve时,执行doneFilter函数
// 当deferred对象被reject时,执行failFilter函数
// 当dederred对象被progress时,执行progressFilter函数
// 返回值:1,返回deferred的promise对象,可修改promise传递的值( 原来resolve,reject 的返回值为a,将a修改为b,返回b,该promise的done或fail收到的返回值变为b );
// 返回值:2,在then方法内创建新的deferred对象并返回其promise
// 返回的promise对象可以链接其他的延迟对象,如done,fail,then等
// 多个then方法时,异步执行( one by one )
// 该方法会过滤掉deferred修改状态的方法,返回值deferred对象的promise 
// ajax方法返回的是一个deferred对象,可以直接使用链式写法
$.ajax('test.json').done(function(resp){
 // done 相当于success回调,其中默认的参数为success回调的参数
 alert('success');
}).fail(function(){
 // fail 相当于error回调
 alert('error');
});

deferred对象境况更换的时候,会触发回调函数。任何回调使用deferred.then(), deferred.always(), deferred.done()大概deferred.fail()加多到这么些目的都是排队等候实践。

你恐怕感兴趣的篇章:

  • jQuery中deferred对象使用办法详解
  • 详解jQuery中的deferred对象的施用(一)
  • jQuery通过deferred对象管理ajax异步
  • jQuery的promise与deferred对象在异步回调中的功能
  • jQuery.deferred对象使用详解
  • 以jQuery中$.Deferred对象为例讲明promise对象是什么处理异步难题
  • jQuery的deferred对象详解
  • jQuery之Deferred对象详解
  • jquery基础教程之deferred对象使用办法
  • 运用jQuery的deferred对象完毕异步按顺序加载JS文件
  • jQuery的deferred对象使用详解
  • 在jQuery1.5中动用deferred对象 着放大镜看Promise
  • 在jQuery 1.5中采取deferred对象的代码(翻译)

jQuery还提供了一个$.when(deferreds)的章程来施行四个或五个延迟对象的回调函数,当它的参数是延迟对象时,它会在全数延迟对象表示的异步实施完后再施行相应的回调函数 

可以见见,代码可读性出色,可扩充性高,况兼大大裁减了调度和排错的复杂度。

那让对延期对象管窥之见的自己十分纳闷,后日抽时间琢磨了一下下,发掘:在某种情形下,四个章程真的能兑现均等的作用。
这种特定的条件是如何呢?

function a(){
 var def = $.Deferred(); // 创建deferred对象 
 function b(){
 alert('start');
 def.resolve(); // 改变deferred对象的状态
 } 
 setTimeout(b, 3000); 
 return def;
}

$.when(a()).done(function(){
 alert("It's callback");
});

3.deferred对象的艺术
3.1大旨用法
(1).生成deferred对象

// 创建延迟对象 <br>var dtd = $.Deferred();

var state = dtd.state();
// 返回deferred对象当前状态,pending / resolved / rejected
// 不接受任何参数

deferred.always( alwaysCallback [, alwaysCallback] );
// 当deferred对象被解决或拒绝时,都执行此方法
// 参数可以是一个函数,或是一个函数数组

dtd.promise( [obj] );
// 目的: 防止其他代码干涉其内部进度和状态
// 返回新的promise对象,包含可以执行的方法( done, fail, then, always, progress, state, promise ),
// 不包含修改Deferred状态的方法( resolve, reject, notify, resolveWith, rejectWith, nodifyWith )
// 需返回deferred对象时,建议返回deferred.promise()

dtd.resolve( [args] )
// 解决deferred对象,调用所有doneCallback函数
// doneCallback可通过then方法中第一个参数设置,也可通过dtd.done( doneCallback )添加
// 参数将传递给doneCallback。参数可选
// 只有deferred对象的创建者才可以调用的方法
// doneCallback中this为deferred或promise对象
// doneCallback只接收一个参数

dtd.resolveWith( context [,args] )
// 解决deferred对象,调用所有doneCallback函数
// 参数:第一个参数为上下文即this对象,doneCallback的this将被修改;第二个参数为数组
// doneCallback中this为调用resolveWith方法的上下文
// doneCallback接收参数个数为该方法第二个参数数组的长度
// 与resolve方法的区别在于,将改变doneCallback函数的this指向

dtd.reject( [args] )
// 拒绝deferred对象,调用所有failCallback函数
// failCallback可通过then方法中第二个参数设置,也可通过dtd.fail( failCallback )添加
// 参数将传递给failCallback。参数可选
// 只有deferred对象的创建者才可以调用的方法
// failCallback中this为deferred或promise对象
// failCallback只接收一个参数

dtd.rejectWith(context, [args] )
// 解决deferred对象,调用所有failCallback函数
// 参数:第一个参数为上下文即this对象,failCallback的this将被修改;第二个参数为数组
// failCallback中this为调用rejectWith方法的上下文
// failCallback接收参数个数为该方法第二个参数数组的长度
// 与resolve方法的区别在于,将改变failCallback函数的this指向

dtd.notify( [args] )
// deferred进行处理时,调用所有的progressCallback函数
// progressCallback可通过then方法中的第3个参数设置,也可以通过deferred.progress( progressCallback )添加
// 通常此方法只能被deferred对象的创建者调用,可通过deferred.promise或then过滤此方法
// 参数可不写。若写有参数,建议为字符串或可返回字符串的函数
// 当deferred进入 resolved 或rejected状态后,再调用notify方法,progressCallback将不再被执行

dtd.notifyWith(context, [args] )
// deferred进行处理时, 调用所有progressCallback函数
// 参数:第一个参数为上下文即this对象,progressCallback的this将被修改;第二个参数为数组
// progressCallback中this为调用rejectWith方法的上下文
// progressCallback接收参数个数为该方法第二个参数数组的长度
// 与resolve方法的区别在于,将改变progressCallback函数的this指向
// 当deferred进入 resolved 或rejected状态后,再调用notifyWith方法,progressCallback将不再被执行

比方要在这些方法之后实践有些回调,就不能够用$.when()了,因为当$.when()的参数不为deferred对象是会直接调用done或许always中的回调函数。
本条时候就要选取deferred对象的其余措施了,照旧地点的艺术,做一些改写 

参数:args -- type(object),传递给回调函数(doneCallbacks)的可选的参数,

还足以同一时间写四个回调,会依照顺序依次推行 

function wait(ms) { 
  var deferred = $.Deferred(); 
  setTimeout(function(){deferred.resolve()}, ms);
  return deferred.promise(); 
}

wait(1500).then(function () {
    // After 1500ms this will be executed 
});
var ajax = function(url, type, param){
 return $.ajax({
 url: url,
 type: type,
 data: param || {} 
 }); 
};

ajax('test.json').done(function(resp){
 alert('success');
}).fail(function(){
 alert('error');
});

        context -- type(object),Context(上下文)作为this对象传递给完了回调函数(doneCallbacks)。

 function a(){
 function b(){
 alert('start');
 } 
 setTimeout(b, 3000); 
} 

(14).promise()

分析一下:
 1). $.Deferred()方法会创制一个deferred对象
 2). def.resolve()会转移deferred对象的图景,deferred对象有三种处境,未产生,成功,失利。
 它有resolve()和reject()五个点子,resolve方法能够把指标意况改为成功,reject方法能够把状态改为战败。
 又有上述的写法会现出难题,重返的deferred对象足以被表面改换状态,所以还提供了八个promise()方法,那个方法会在deferred对象的底蕴上回来三个新的deferred对象,不一样的是,再次回到的对象只设有可被观察到状态,而不富有可退换其状态的点子,类似重回了多个只读的deferred对象。
 所以一样的事例能够改写成那样 

var callbackFunc = function(){console.log(arguments[0]);}
var dfd = $.Deferred();
dfd.fail(callbackFunc);
dfd.reject("fail"); //'fail'

你或者感兴趣的小说:

  • 详解jQuery中的deferred对象的选拔(一)
  • jQuery通过deferred对象管理ajax异步
  • jQuery的promise与deferred对象在异步回调中的功效
  • jQuery.deferred对象使用详解
  • 以jQuery中$.Deferred对象为例批注promise对象是怎么管理异步难点
  • jQuery的deferred对象详解
  • jQuery之Deferred对象详解
  • jquery基础教程之deferred对象使用方法
  • 选拔jQuery的deferred对象实现异步按梯次加载JS文件
  • jQuery的deferred对象使用详解
  • 在jQuery1.5中应用deferred对象 着放大镜看Promise
  • 在jQuery 1.5中动用deferred对象的代码(翻译)
  • jQuery的deferred对象使用详解

那么难点来了,promises和deferred对象毕竟是个如毕建华西呢?

当你需求四个以致更加多的异步截至后才调用回调函数,同有的时候间这一个异步ajax恐怕还索要修改传输格局type只怕传数据data时,代码就体现很乱,可读性比很差。 
为此就能够对ajax进行重新卷入,提升代码可读性 

$.ajax({})
  .done(function(){ alert("success!"); })
  .fail(function(){ alert("fail!"); });

deferred对象还也有四个then方法,其实它是三个结合done和fail的法子,它承受一到八个参数,如若有八个参数,那么首先个就是done方法的回调函数,第二个是fail方法的回调函数。如若唯有四个参数,那正是done方法的回调函数。 

1).串行调用Ajax

1)Promise

(4)典型的Ajax操作

var func = function(arg){console.log(arg);};
$.Deferred().done(func).resolve("done!"); //'done!'
var func = function(arg1,arg2){console.log(arg1.name   ','   arg2);};
$.Deferred().done(func).resolve({name:'Lucy'},'How are you!'); // 'Lucy,How are you!'

(13)deferred.pipe()

var address = $.ajax({}); 
var tweets = $.ajax({}); 
var facebook = $.ajax({}); 
render_side_bar = function(address, tweets, facebook){ 
  //render sidebar 
}
render_no_side_bar = function () { }
$.when(address, tweets, facebook).then(render_side_bar, render_no_side_bar)

(4).绑定回调函数

var func = function(){console.log("start");} 
var dfd = $.Deferred(func); //'start' create a deferred object

 看名就会知道意思,只要Deferred对象的情景暴发转移(消除也许拒绝)均会调用alwaysCallbacks。

前段时间的ajax操作的写法是:

var promises = []; 
$.ajax({
  success: function() { 
    promises.push('resolved'); 
    check(); 
  } 
}); 
$.ajax({ 
  success: function() { 
    promises.push('resolved'); 
    check();
  } 
}); 
$.ajax({ 
  success: function() { 
    promises.push('resolved'); 
    check(); 
  } 
}); 
var check = function() { //checks for all 3 values in the promises array }

2.4.链式调用
jQuery中古板的ajax操作是那样的:

这种方式对于callbacks函数调用来讲早就很不利了,并行获得数据,可读性优异。劣点就是代码冗长,可扩展性差,调节和测量检验和排错的复杂度高。

一旦在情景改变后附属类小部件贰个callback则会立刻实践callback,因而不必顾忌deferred对象曾几何时被resolved或许rejected,因为不论是何时,参数都会不错地传递给callbacks。

var func = function(arg){console.log(arg);};
$.Deferred().fail(func).reject("error!"); //'error!'
var func = function(ctx,arg){console.log(ctx.name   ','   arg);};
$.Deferred().fail(func).reject({name:'Mark'},'What happend!'); // 'Mark,What happend!'

参数字传送入三个非Deferred和Promise对象,那么该参数会被当成一个被消除(resolved)的推移对象,而且绑定到上面的其余doneCallbacks都会被当下实践。

(11)deferred.notify(args) and deferred.notifyWith()

3.2.deferred对象的点子
(1)$.Deferred([beforeStart]) -- 创制一个deferred对象,参数类型为Function,是贰个在构造函数从前调用的函数。

2.deferred目的的几大收益
2.1.为同样操作内定多少个回调函数
deferred对象的益处之一,正是它同意你为一个操作增加多少个回调函数,那在价值观的ajax中是敬谢不敏落实的。

参数:

(3)deferred.fail(failCallbacks [,failCallbacks]) -- 当deferred(延迟)对象拒绝时,调用加多管理程序。

args:接受叁个只怕几个参数,全体的参数都足以是贰个纯净的函数只怕函数数组,当deferred(延迟)对象消除时,doneCallbacks被调用。回调是根据他们增多的逐个实践的。

(6)deferred.promise([target]) -- 返回Deferred(延迟)的Promise(承诺)对象。

(5)deferred.reject(args) and deferred.rejectWith(context [,args]) -- 拒绝Deferred(延迟)对象,并基于给定的args参数(rejectWith给定context)调用任何failCallbacks。

复制代码 代码如下:

参数仅传入二个独自的Deferred对象,重返它的Promise对象。

(3)The Wait promise

        context -- type(object),Context(上下文)作为this对象传递给完了回调函数(doneCallbacks)。

(3).退换deferred对象的境况

2).并行调用Ajax

$.when( { name: 123 } ).done(
  function(arg) { alert(arg.name); } /* alerts "123" */
);

参数:args -- type(object),传递给回调函数(doneCallbacks)的可选的参数,

这种格局代码可读性差,功能低,晦涩难懂,调节和测量检验和排错的复杂度大。

var d1 = $.Deferred();
var d2 = $.Deferred();

$.when( d1, d2 ).done(function ( v1, v2 ) {
  console.log( v1 ); // "Fish"
  console.log( v2 ); // "Pizza"
});

d1.resolve( "Fish" );
d2.resolve( "Pizza" );
var callbackFunc = function(){console.log(arguments[0]);}
var dfd = $.Deferred();
dfd.done(callbackFunc);
dfd.resolve("hello"); //'hello'

2.2.为四个操作钦命同三个回调函数
deferred对象的功利之二,正是它同意你为多个操作钦定同三个回调函数,那在观念的ajax中也是力不胜任兑现的。

var func = function () {
  console.log(this.name   ','   arguments[0]   ' '   arguments[1]);
};
$.Deferred().fail(func).rejectWith({ name: "Mark" }, ["what", "happend!"]); // 'Mark,What happend!'

(15)deferred.isRejected() 和 deferred.isResolved() --  从jQuery 1.7初始被弃用,较新本子的jQuery类库中曾经被剔除,能够利用state()方法替代那三个主意。

doneFilter --   type(Function),当Deferred(延迟)对象得到化解时被调用的二个函数。
failFilter --   type(Function),当Deferred(延迟)对象拒绝时被调用的一个函数,可选。
progressFilter --   type(Function),当Deferred(延迟)对象生成速度通报时被调用的二个函数,可选。
其实,then方法能够领略成,把done(),fail(),progress()合在一同写。

$.Deferred().state();//"pending" 地点陈说过deferre(延迟)对象的两种状态,这么些点子对于debug特别有用,比如,在预备reject四个deferred对象在此之前,判定它是否处在resolved状态。

2.3.非Ajax操作的回调函数
deferred对象的功利之三,就是它不再拘泥于ajax操作,率性的操作(ajax操作or本地操作/异步操作or同步操作)都足以行使deferred对象,钦点回调函数。

你或许感兴趣的稿子:

  • jQuery中deferred对象使用方法详解
  • 详解jQuery中的deferred对象的采取(一)
  • jQuery通过deferred对象管理ajax异步
  • jQuery的promise与deferred对象在异步回调中的功用
  • 以jQuery中$.Deferred对象为例解说promise对象是怎么管理异步难点
  • jQuery的deferred对象详解
  • jQuery之Deferred对象详解
  • jquery基础教程之deferred对象使用办法
  • 行使jQuery的deferred对象完成异步按顺序加载JS文件
  • jQuery的deferred对象使用详解
  • 在jQuery1.5中利用deferred对象 着放大镜看Promise
  • 在jQuery 1.5中动用deferred对象的代码(翻译)
  • jQuery的deferred对象使用详解

不精晓动画哪天甘休,可是又不能够不在动画截至的时候做一些操作还是是开发银行别的的卡通,这种情形下,若是采用别的的方法,很轻便导致代码可读性差,尤其是还夹带着有个别任何的操作,例如渲染、表单操作等,以后jQuery会为你的卡通操作重临三个Promise,那样那一个动画片能够张开链式操作。

二种写法相比较能够很分明的看出来,done()也正是守旧ajax操作的success方法,fail()也正是古板ajax操作的fail方法。相对于古板的写法,代码可读性提升了。

pending-->resolved,施行设置中任何的doneCallbacks(done()钦命),参数由resolved传递给doneCallbacks。
pending-->rejected,实行设置中别的的failCallbacks(fail()钦命),参数由resolved传递给failCallbacks。
pending-->resolved/rejected,执行always()指定的callbacks,参数由resolved传递给callbacks。

(12)deferred.progress()

调用deferred.resolve() 也许deferred.resolveWith()调换Deferred(递延)到resolved(消除)的境况,并马上施行设置中此外的doneCallbacks。

调用deferred.reject() 恐怕deferred.rejectWith()调换Deferred(递延)到rejected(拒绝)的图景,并及时实行设置中其它的failCallbacks。

var func1 = function(){console.log("1");},
   func2 = function(){console.log("2");},
   func3 = function(){console.log("3");};
var dfd = $.Deferred();
dfd.fail([func1,func2],func3,[func2,func1]);
dfd.reject(); // "1 2 3 2 1"
$.ajax({ success: function() { 
  $.ajax({ success: function() {
    $.ajax({ //callbacks... 
        }); 
  }); 
});  

二个很独立的耗费时间操作

deferred对象是对Promises接口的贯彻。jQuery 1.5版本以及以往全部的Ajax重返的jqXH宝马7系对象正是二个deferred对象。

$.ajax({
  url: "",
   success: function(){
    alert("success!");
   },
   error:function(){
    alert("error!");
   }
});

reject和rejectWith的分别就同样fire和fireWith的分别。

var dfd = $.Deferred(); // create a deferred object
  var wait = function(dtd){
    var tasks = function(){
      alert("over!");
      dtd.resolve(); // change the state of the deferred object from pending to resolved
    };
    setTimeout(tasks,50000);
    return dtd;
  };


$.when(wait(dtd))
  .done(function(){ alert("success!"); })
  .fail(function(){ alert("error!"); });
var filterResolve = function () {
   var dfd = $.Deferred(),
     filtered = dfd.then(function (value) { return value * 2; });
   dfd.resolve(5);
   filtered.done(function (value) { console.log(value); });
};
filterResolve(); //'10'

var defer = $.Deferred(),
   filtered = defer.then(null, function (value) {
     return value * 3;
   });

defer.reject(6);
filtered.fail(function (value) {
   alert("Value is 3*6 = "   value);
});

var dfd = $.Deferred(); //create a deferred object (2).deferred对象的图景

$.when($.ajax({}), $.ajax({}))
  .done(function(){ alert("success!"); })
  .fail(function(){ alert("error!"); });
var func1 = function(){console.log("1");},
   func2 = function(){console.log("2");},
   func3 = function(){console.log("3");};
var dfd = $.Deferred();
dfd.done([func1,func2],func3,[func2,func1]);
dfd.resolve(); // "1 2 3 2 1"

(7)$.when(deferreds) -- 提供一种方法来实行一个或七个目的的回调函数。

deferred对象有三种情状

(1)复杂的动画

(8)deferred.then(doneFilter [,failFilter] [,progressFilter]) -- 当Deferred(延迟)对象消除,拒绝或仍在进展中时,调用增多管理程序。

$.ajax("test.html")
  .done(function(){ alert("first success callback!");} )
  .fail(function(){ alert("there is an error!"); } )
  .done(function(){ alert("second success callback!");} );

resolve和resolveWith的区分就一律fire和fireWith的区分。

一、前言 jQuery1.5事先,如果急需频仍Ajax操作,大家一般会动用上面包车型客车三种办法:

pending:代表操作处于未到位的情景,任何deferred(延迟)对象起始于pending状态。
resolved:代表操作成功。
rejected:表示操作退步。
state()方法再次回到deferred对象的前段时间情形。

(9)deferred.always(alwaysCallbacks [,alwaysCallbacks]) -- 当Deferred(延迟)对象化解或拒绝时,实践alwaysCallbacks。

二、详解 2.什么是deferred对象?
deferred对象即延迟对象,它是jQuery 1.5本子引进的一种回调函数的缓慢解决方案,代表了就要达成的某种操作,并且提供了一些艺术,辅助用户使用。

(5)一些耗费时间的轮回操作

$.when().state(); // "resolved"

参数为多个Deferred对象,该格局依照多少个新的“宿主” Deferred(延迟)对象,追踪全数已经过Deferreds聚焦状态,再次来到一个Promise对象。当全体的延期对象被化解(resolve)时,“宿主” Deferred(延迟)对象才会搞定(resolved)该方法,可能当个中有多个延迟对象被驳回(rejected)时,“宿主” Deferred(延迟)对象就能reject(拒绝)该形式。

window.queue = $.when() $('#list').on('click', function() { window.queue = window.queue.then(function() { //do the thing }) } )

var func = function () {
  console.log(this.name   ','   arguments[0]   ' '   arguments[1]   ' '   arguments[2]);
};
$.Deferred().done(func).resolveWith({ name: "Lucy" }, ["How", "are", "you!"]);//'Lucy,How are you!'

(16)deferred.pipe() -- 从jQuery 1.8始发被弃用。

(2)deferred.done(doneCallbacks [,doneCallbacks]) -- 当deferred(延迟)对象消除时,调用增加管理程序。

function func() {
  var dfd = $.Deferred();
  setTimeout(function () {
    dfd.resolve("hurry");
  }, 500);
  return dfd.promise();
};

$.when(func()).done(function (arg) {
  alert(arg); /*alert "hurry"*/
});

无参数,再次回到三个resolved(化解)状态的Promise对象。

args:接受七个也许八个参数,全部的参数都得以是叁个纯净的函数或许函数数组,当deferred(延迟)对象拒绝时,failCallbacks被调用。回调是根据他们增加的一一施行的。

jQuery1.5之后,扩大了deferred对象。由此能够用上面这种方法完成和方面同样的急需。

有参数时,会将事件绑定到参数上,然后回来该参数对象(再次回到的实际是四个扩大的Promise(承诺)对象)。

var fun1 = function(){console.log(arguments[0]);},
  fun1 = function(){console.log(arguments[0]);};
var dfd = $.Deferred();
dfd.done(fun1);
dfd.resolve("hello"); //'hello'
dfd.done(fun2); //'hello'

 参数可选,无参数时回来八个Promise(承诺)对象,Promise(承诺)对象仅会暴光那个急需绑定额外的拍卖或决断状态的延期方法(then, done, fail, always,pipe, progress, state,和 promise)时,并不会暴光任何用于转移状态的延迟方法(resolve, reject, notify,resolveWith, rejectWith, 和 notifyWith)。使用Promise(承诺)会堵住别的人破坏你塑造的promise。

var obj = {
  hello: function (name) {
    alert("Hello "   name);
  }
},
// Create a Deferred
dfd = $.Deferred();

// Set object as a promise
dfd.promise(obj);

// Resolve the deferred
dfd.resolve("John");

// Use the object as a Promise
obj.done(function (name) {
   obj.hello(name); // will alert "Hello John"
}).hello("Karl");
var f1 = function(){console.log("done");}, 
   f2 = function(){console.log("fail");}, 
   f3 = function(){console.log("always");};

var dfd = $.Deferred();
dfd.done(f1).fail(f2).always(f3);

//if
dfd.resolve(); //'done' 'always'
//if
dfd.reject(); //'fail' 'always'

(10)deferred.state() -- 获取三个Deferred(延迟)对象的脚下气象,不收受任何参数。

本文由必发88官网发布,转载请注明来源:jQuery的deferred对象使用详解,deferred对象使用详解