递延对象总括,jQuery的Deferred对象概述

jQuery的Deferred对象概述

2017/03/02 · CSS

本文由 伯乐在线 –
HansDo
翻译,叙帝利
校稿。未经许可,禁止转发!
英文出处:Aurelio De
Rosa。欢迎插手翻译组。

很久以来,JavaScript
开发者们习惯用回调函数的形式来实施一些任务。最普遍的例证就是使用
addEventListener()函数来添加一个回调函数, 用来在指定的事件(如
click
keypress)被触发时,执行一五种的操作。回调函数简单可行——在逻辑并不复杂的时候。遗憾的是,一旦页面的复杂度扩张,而你由此须求履行很多互为或串行的异步操作时,那几个回调函数会让你的代码难以维护。

ECMAScript 2015(又名 ECMAScript 6)
引入了一个原生的章程来缓解这类难点:promises。即便你还不驾驭 promise
是何等,可以翻阅那篇小说《Javascript
Promise概述》。jQuery
则提供了独到的另一种 promises,叫做 Deferred
对象。而且 Deferred
对象的引入时间要比 ECMAScript 引入 promise
早了某些年。在这篇文章里,我会介绍 Deferred
对象和它试图缓解的难题是什么。

deferred对象是jQuery对Promises接口的兑现。它是非同步操作的通用接口,可以被作为是一个等候达成的职务,开发者通过一些因此的接口对其进行安装。事实上,它扮演代理人(proxy)的角色,将那一个非同步操作包装成具有某些统一特性的目标,典型例子就是Ajax操作、网页动画、web
worker等等。

jQuery之Deferred对象详解,jquerydeferred

deferred对象是jQuery对Promises接口的完毕。它是非同步操作的通用接口,可以被当作是一个等候已毕的职分,开发者通过一些由此的接口对其展开设置。事实上,它扮演代理人(proxy)的角色,将那个非同步操作包装成所有某些统一特性的目的,典型例子就是Ajax操作、网页动画、web
worker等等。

jQuery的具有Ajax操作函数,默许重临的就是一个deferred对象。

Promises是什么

鉴于JavaScript单线程的表征,借使某个操作耗时很长,其余操作就必需排队等待。为了防止一切程序失去响应,常常的化解办法是将那个排在前面的操作,写成“回调函数”(callback)的花样。那样做即使可以解决难题,不过有一对明明缺点:

1.回调函数往往写成函数参数的款式,导致函数的输入和输出卓殊混乱,整个程序的可阅读性差;
2.回调函数往往只可以指定一个,借使有七个操作,就必要改写回调函数。
3.全副程序的运转流程被打乱,除错和调试的难度都对应扩张。

Promises就是为着化解这几个题目而提出的,它的第一目标就是顶替回调函数,成为非同步操作的解决方案。它的焦点情想就是让非同步操作再次回到一个目标,其余操作都指向那个目的来形成。比如,假定ajax操作再次来到一个Promise对象。

复制代码 代码如下:

var promise = get(”);

下一场,Promise对象有一个then方法,可以用来指定回调函数。一旦非同步操作完结,就调用指定的回调函数。

复制代码 代码如下:

promise.then(function (content) {
  console.log(content)
})

可以将地方两段代码合并起来,那样程序的流水线看得更明白。

复制代码 代码如下:

get(‘ (content) {
  console.log(content)
})

在1.7版以前,jQuery的Ajax操作使用回调函数。

复制代码 代码如下:

$.ajax({
    url:”/echo/json/”,
    success: function(response)
    {
       console.info(response.name);
    }
});

1.7版之后,Ajax操作直接重回Promise对象,这象征可以用then方法指定回调函数。

复制代码 代码如下:

$.ajax({
    url: “/echo/json/”,
}).then(function (response) {
    console.info(response.name);
});

deferred对象的章程

$.deferred()方法

效益是生成一个deferred对象。

复制代码 代码如下:

var deferred = $.deferred();

done() 和 fail()

那多少个方法都用来绑定回调函数。done()指定非同步操作成功后的回调函数,fail()指定失利后的回调函数。

复制代码 代码如下:

var deferred = $.Deferred();
deferred.done(function(value) {
   alert(value);
});

它们重临的是原来的deferred对象,因而得以运用链式写法,在后头再链接其他方法(包蕴done和fail在内)。

resolve() 和 reject()

那多个主意用来改变deferred对象的意况。resolve()将气象改为非同步操作成功,reject()改为操作失利。

复制代码 代码如下:

var deferred = $.Deferred();
deferred.done(function(value) {
   alert(value);
});
deferred.resolve(“hello world”);

若果调用resolve(),就会相继执行done()和then()方法指定的回调函数;一旦调用reject(),就会相继执行fail()和then()方法指定的回调函数。

state方法

该办法用来回到deferred对象近来的意况。

复制代码 代码如下:

var deferred = new $.Deferred();
deferred.state();  // “pending”
deferred.resolve();
deferred.state();  // “resolved”

该措施的再次来到值有多少个:

1.pending:表示操作还尚未完毕。
2.resolved:表示操作成功。
3.rejected:表示操作退步。

notify() 和 progress()

progress()用来指定一个回调函数,当调用notify()方法时,该回调函数将推行。它的用意是提供一个接口,使得在非同步操作实践进度中,可以举办某些操作,比如定期回去过程条的进程。

复制代码 代码如下:

 var userProgress = $.Deferred();
    var $profileFields = $(“input”);
    var totalFields = $profileFields.length
    userProgress.progress(function (filledFields) {
        var pctComplete = (filledFields/totalFields)*100;
        $(“#progress”).html(pctComplete.toFixed(0));
    });
    userProgress.done(function () {
        $(“#thanks”).html(“Thanks for completing your
profile!”).show();
    });
    $(“input”).on(“change”, function () {
        var filledFields =
$profileFields.filter(“[value!=”]”).length;
        userProgress.notify(filledFields);
        if (filledFields == totalFields) {
            userProgress.resolve();
        }
    });

then()

then()的成效也是指定回调函数,它可以承受八个参数,也就是八个回调函数。第二个参数是resolve时调用的回调函数,第四个参数是reject时调用的回调函数,首个参数是progress()方法调用的回调函数。

复制代码 代码如下:

deferred.then( doneFilter [, failFilter ] [, progressFilter ] )

在jQuery
1.8此前,then()只是.done().fail()写法的语法糖,二种写法是等价的。在jQuery
1.8将来,then()再次来到一个新的deferred对象,而done()重返的是原来的deferred对象。借使then()指定的回调函数有重回值,该重临值会作为参数,传入后边的回调函数。

复制代码 代码如下:

var defer = jQuery.Deferred();
defer.done(function(a,b){
            return a * b;
}).done(function( result ) {
            console.log(“result = ” + result);
}).then(function( a, b ) {
            return a * b;
}).done(function( result ) {
            console.log(“result = ” + result);
}).then(function( a, b ) {
            return a * b;
}).done(function( result ) {
            console.log(“result = ” + result);
});
defer.resolve( 2, 3 );

在jQuery 1.8版本之前,下边代码的结果是:

复制代码 代码如下:

result = 2
result = 2
result = 2

在jQuery 1.8本子之后,重返结果是

复制代码 代码如下:

result = 2
result = 6
result = NaN

那或多或少内需特地引起注意。

复制代码 代码如下:

$.ajax( url1, { dataType: “json” } )
.then(function( data ) {
    return $.ajax( url2, { data: { user: data.userId } } );
}).done(function( data ) {
  // 从url2收获的数目
});

下面代码最终更加done方法,处理的是从url2得到的多少,而不是从url1得到的多寡。

行使then()会修改再次来到值这几个特性,大家可以在调用其他回调函数以前,对前一步操作再次回到的值举行处理。

复制代码 代码如下:

var post = $.post(“/echo/json/”)
    .then(function(p){
        return p.firstName;
    });
post.done(function(r){ console.log(r); });

上面代码先利用then()方法,从重临的数码中取出所须要的字段(firstName),所未来边的操作就足以只处理那一个字段了。

有时,Ajax操作再次来到json字符串里面有一个error属性,表示暴发错误。这一个时候,传统的法门只可以是透过done()来判断是还是不是发生错误。通过then()方法,可以让deferred对象调用fail()方法。

复制代码 代码如下:

var myDeferred = $.post(‘/echo/json/’,
{json:JSON.stringify({‘error’:true})})
    .then(function (response) {
            if (response.error) {
                return $.Deferred().reject(response);
            }
            return response;
        },function () {
            return $.Deferred().reject({error:true});
        }
    );
myDeferred.done(function (response) {
        $(“#status”).html(“Success!”);
    }).fail(function (response) {
        $(“#status”).html(“An error occurred”);
    });

always()

always()也是指定回调函数,不管是resolve或reject都要调用。

pipe方法

pipe方法接受一个函数作为参数,表示在调用then方法、done方法、fail方法、always方法指定的回调函数从前,先运行pipe方法指定的回调函数。它一般用来对服务器再次来到的数量做始发处理。

promise对象

多数情状下,我们不想让用户从外表更改deferred对象的图景。那时,你可以在deferred对象的基础上,再次来到一个针对性它的promise对象。大家可以把后人驾驭成,promise是deferred的只读版,或者更易懂地知道成promise是一个对即将完毕的任务的承诺。

您可以由此promise对象,为原本的deferred对象添加回调函数,查询它的动静,不过力不从心转移它的气象,也就是说promise对象不容许你调用resolve和reject方法。

复制代码 代码如下:

function getPromise(){
    return $.Deferred().promise();
}
try{
    getPromise().resolve(“a”);
} catch(err) {
    console.log(err);
}

上边的代码会出错,呈现TypeError {} 。

jQuery的ajax()
方法再次回到的就是一个promise对象。其它,Animation类操作也得以拔取promise对象。

复制代码 代码如下:

var promise = $(‘div.alert’).fadeIn().promise();

$.when()方法

$.when()接受多少个deferred对象作为参数,当它们整个运行成功后,才调用resolved状态的回调函数,但假若其中有一个破产,就调用rejected状态的回调函数。它相当于将五个非同步操作,合并成一个。

复制代码 代码如下:

$.when(
    $.ajax( “/main.php” ),
    $.ajax( “/modules.php” ),
    $.ajax( “/lists.php” )
).then(successFunc, failureFunc);

地点代码表示,要等到多少个ajax操作都终止未来,才实施then方法指定的回调函数。

when方法里面要履行稍微个操作,回调函数就有多少个参数,对应前边每一个操作的回来结果。

复制代码 代码如下:

$.when(
    $.ajax( “/main.php” ),
    $.ajax( “/modules.php” ),
    $.ajax( “/lists.php” )
).then(function (resp1, resp2, resp3){
    console.log(resp1);
    console.log(resp2);
    console.log(resp3);
});

上边代码的回调函数有八个参数,resp1、resp2和resp3,依次对应前边多少个ajax操作的回来结果。

when方法的另一个功能是,要是它的参数重回的不是一个Deferred或Promise对象,那么when方法的回调函数将
立即运行。

复制代码 代码如下:

$.when({testing: 123}).done(function (x){
  console.log(x.testing); // “123”
});

地方代码中指定的回调函数,将在when方法后边立时运行。

接纳这几个特性,大家可以写一个装有缓存效果的异步操作函数。也就是说,第三遍调用那些函数的时候,将推行异步操作,前面再调用这几个函数,将会回到缓存的结果。

复制代码 代码如下:

function maybeAsync( num ) {
  var dfd = $.Deferred();
  if ( num === 1 ) {
    setTimeout(function() {
      dfd.resolve( num );
    }, 100);
    return dfd.promise();
  }
  return num;
}
$.when(maybeAsync(1)).then(function (resp){
  $(‘#target’).append(‘<p>’ + resp + ‘</p>’);
});
$.when(maybeAsync(0)).then(function (resp){
  $(‘#target’).append( ‘<p>’ + resp + ‘</p>’);
});

上边代码表示,假如maybeAsync函数的参数为1,则履行异步操作,否则立时赶回缓存的结果。

实例

递延对象总括,jQuery的Deferred对象概述。wait方法

大家得以用deferred对象写一个wait方法,表示等待多少微秒后再实施。

复制代码 代码如下:

$.wait = function(time) {
  return $.Deferred(function(dfd) {
    setTimeout(dfd.resolve, time);
  });
}

行使格局如下:

复制代码 代码如下:

$.wait(5000).then(function() {
  alert(“Hello from the future!”);
});

改写setTimeout方法

在上边的wait方法的底蕴上,还是可以改写set提姆eout方法,让其回来一个deferred对象。

复制代码 代码如下:

function doSomethingLater(fn, time) {
  var dfd = $.Deferred();
  setTimeout(function() {
    dfd.resolve(fn());
  }, time || 0);
  return dfd.promise();
}
var promise = doSomethingLater(function (){
  console.log( ‘已经推迟执行’ );
}, 100);

自定义操作使用deferred接口

俺们可以拔取deferred接口,使得任意操作都得以用done()和fail()指定回调函数。

复制代码 代码如下:

Twitter = {
  search:function(query) {
    var dfr = $.Deferred();
    $.ajax({
     url:””,
     data:{q:query},
     dataType:’jsonp’,
     success:dfr.resolve
    });
    return dfr.promise();
  }
}

选择形式如下:

复制代码 代码如下:

Twitter.search(‘intridea’).then(function(data) {
  alert(data.results[0].text);
});

deferred对象的另一个优势是足以附加四个回调函数。

复制代码 代码如下:

function doSomething(arg) {
  var dfr = $.Deferred();
  setTimeout(function() {
    dfr.reject(“Sorry, something went wrong.”);
  });
  return dfr;
}
doSomething(“uh oh”).done(function() {
  alert(“Won’t happen, we’re erroring here!”);
}).fail(function(message) {
  alert(message)
});

设计思路(意图)

Deferred对象简史

Deferred目标是在 jQuery 1.5
中引入的,该目标提供了一文山会海的格局,能够将四个回调函数注册进一个回调队列里、调用回调队列,以及将一并或异步函数执行结果的打响仍然败诉传递给相应的处理函数。从那以后,Deferred
对象就成了商量的话题,
其中不乏批评意见,那一个看法也直接在变更。一些出色的批评的观点如《你并没有驾驭Promise
》和《论
Javascript 中的 Promise 以及 jQuery
是何等把它搞砸的》。

Promise 对象 是和 Deferred
对象一起作为 jQuery 对 Promise 的一种落成。在 jQuery1.x 和 2.x 版本中,
Deferred 对象听从的是《CommonJS Promises
提案》中的约定,而 ECMAScript
原生 promises 方法的树立基础《Promises/A+
提案》也是以这一提案书为底蕴衍生而来。所以就好像大家一开始波及的,之所以
Deferred 对象没有根据《Promises/A+
提案》,是因为那时候后者根本还没被构想出来。

出于 jQuery 扮演的先行者的角色以及后向兼容性难点,jQuery1.x 和 2.x 里
promises 的使用方法和原生 Javascript 的用法并差别。别的,由于 jQuery
自己在 promises 方面按照了此外一套提案,那造成它无法合作其余完毕promises 的库,比如 Q library。

唯独即未来临的 jQuery 3
改进了 同原生
promises(在 ECMAScript2015
中贯彻)的互操作性。固然为了向后卓殊,Deferred
对象的要紧格局之一(then())的点子签名依旧会有些不相同,但作为方面它已经同
ECMAScript 2015 标准更是一致。

jQuery的持有Ajax操作函数,默许重临的就是一个deferred对象。

jquery的实例对象与jquery的大局对象在用法上有什差异

{ this.id = sId; //函数内部的 this 是这么些函数的实例 } 用
prototype对象,这些目的可以用 jQuery 的各个函数。 $(‘body
a’).click(function(
 

 

jQuery中的回调函数

举一个例证来精通为啥我们必要用到 Deferred目的。使用 jQuery
时,平时会用到它的 ajax
方法执行异步的多少请求操作。我们不妨假若你在开发一个页面,它可以发送
ajax 请求给 GitHub API,目标是读取一个用户的 Repository
列表、定位到近年来创新一个
Repository,然后找到第二个名为“README.md”的文书并得到该公文的内容。所以基于以上描述,每一个伸手唯有在前一步成功后才能早先。换言之,那一个请求必须各类执行

地点的叙说可以转换成伪代码如下(注意自己用的并不是实在的 Github API):

JavaScript

var username = ‘testuser’; var fileToSearch = ‘README.md’;
$.getJSON(” + username + ‘/repositories’,
function(repositories) { var lastUpdatedRepository =
repositories[0].name; $.getJSON(” +
username + ‘/repository/’ + lastUpdatedRepository + ‘/files’,
function(files) { var README = null; for (var i = 0; i <
files.length; i++) { if (files[i].name.indexOf(fileToSearch) >= 0)
{ README = files[i].path; break; } }
$.getJSON(” + username + ‘/repository/’ +
lastUpdatedRepository + ‘/file/’ + README + ‘/content’,
function(content) { console.log(‘The content of the file is: ‘ +
content); }); }); });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var username = ‘testuser’;
var fileToSearch = ‘README.md’;
 
$.getJSON(‘https://api.github.com/user/’ + username + ‘/repositories’, function(repositories) {
  var lastUpdatedRepository = repositories[0].name;
 
$.getJSON(‘https://api.github.com/user/’ + username + ‘/repository/’ + lastUpdatedRepository + ‘/files’, function(files) {
    var README = null;
 
for (var i = 0; i < files.length; i++) {
      if (files[i].name.indexOf(fileToSearch) >= 0) {
        README = files[i].path;
 
break;
      }
    }
 
$.getJSON(‘https://api.github.com/user/’ + username + ‘/repository/’ + lastUpdatedRepository + ‘/file/’ + README + ‘/content’, function(content) {
      console.log(‘The content of the file is: ‘ + content);
    });
  });
});

如您所见,使用回调函数的话,我们须求频仍嵌套来让 ajax
请求依据大家盼望的一一执行。当代码里冒出众多嵌套的回调函数,或者有诸多互为独立但必要将它们一起的回调时,大家一再把那种意况称作“回调地狱( callback hell )“。

为了多少改进一下,你可以从自我成立的匿名函数中提取出命名函数。但这支援并不大,因为大家仍然在回调的炼狱中,依然面对着回调嵌套和共同的难题。那时是
DeferredPromise目的上场的时候了。

Promises是什么

jQuery对象难点

第二个是创制了一个validator对象,validator是以此目的的引用
首个是在this[0]其一DOM对象上沾满一个变量,名叫validator,这一个目的的值就是第一行的那多少个validator,也就是刚刚创立的validator对象。
而后通过this[0]本条DOM对象就足以博获得validator那些目的了。
 

deferred对象是jQuery对Promises接口的完毕。它是非同步操作的通用接口,可以被当作是一个等候完结的职务…

实施jQuery.when将会重返一个Promise对象,大家称为由when生成的Promise对象,假诺给定的兼具Promise对象均已举行,就及时施行

Deferred和Promise对象

Deferred 对象可以被用来举办异步操作,例如 Ajax 请求和卡通的兑现。在
jQuery 中,Promise目的是只可以由Deferred对象或 jQuery 对象创制。它抱有
Deferred 对象的一有的方法:always(),done(), fail(),
state()then()。大家在下一节会讲到这么些点子和其余细节。

一旦您来自于原生 Javascript
的社会风气,你可能会对那多个对象的留存感到迷惑:为何 jQuery
有八个目的(DeferredPromise)而原生JS 唯有一个(Promise)?
在自己写作的书《jQuery
实践(第三版)》里有一个类比,能够用来诠释这些题材。

Deferred对象一般用在从异步操作重返结果的函数里(再次回到结果可能是
error,也说不定为空)——即结果的生产者函数里。而回到结果后,你不想让读取结果的函数改变
Deferred 对象的景色(译者注:包含 Resolved 解析态,Rejected
拒绝态),那时就会用到 promise 对象——即 Promise
对象总在异步操作结果的消费者函数里被应用。

为了理清那么些概念,大家如果你必要落成一个依据 promise
timeout()函数(在本文稍后会显得这么些事例的代码)。你的函数会等待指定的一段时间后回去(那里没有再次来到值),即一个生产者函数而以此函数的呼应消费者们并不在乎操作的结果是马到功成(解析态
resolved)依旧败诉(拒绝态 rejected),而只关切他们须求在 Deferred
对象的操作成功、失利,或者接受进展通知后继之执行一些别样函数。其它,你还期待能保险消费者函数不会活动解析或拒绝
Deferred对象。为了完成这一目标,你无法不在劳动者函数timeout()中开创
Deferred 对象,并只回去它的 Promise 对象,而不是
Deferred对象自我。那样一来,除了timeout()函数之外就从不人可以调用到resolve()reject()接着改变
Deferred 对象的场所了。

在这个 StackOverflow 问题
里你可以领会到更加多关于 jQuery 中 Deferred 和 Promise 对象的两样。

既是你早就了然里这八个目的,让我们来看一下它们都包含哪些措施。

由于JavaScript单线程的特色,假设某个操作耗时很长,其余操作就必需排队等候。为了幸免任何程序失去响应,寻常的解决方法是将那么些排在后边的操作,写成“回调函数”(callback)的款型。那样做即便可以解决难点,不过有局地众所周知缺点:

 

Deferred对象的办法

Deferred对象万分灵活并提供了您或许需求的装有办法,你可以透过调用
jQuery.Deferred() 像下边一样成立它:

JavaScript

var deferred = jQuery.Deferred();

1
var deferred = jQuery.Deferred();

或者,使用 $作为 jQuery 的简写:

JavaScript

var deferred = $.Deferred();

1
var deferred = $.Deferred();

创建完 Deferred目的后,就足以接纳它的一多种措施。处了已经被撇下的
removed 方法外,它们是:

  • always(callbacks[, callbacks, ..., callbacks]): 添加在该 Deferred
    对象被分析或被拒绝时调用的处理函数
  • done(callbacks[, callbacks, ..., callbacks]): 添加在该 Deferred
    对象被解析时调用的处理函数
  • fail(callbacks[, callbacks, ..., callbacks]): 添加在该 Deferred
    对象被驳回时调用的处理函数
  • notify([argument, ..., argument]):调用 Deferred 对象上的
    progressCallbacks 处理函数并传递制定的参数
  • notifyWith(context[, argument, ..., argument]):
    在制定的光景文中调用 progressCallbacks 处理函数并传递制定的参数。
  • progress(callbacks[, callbacks, ..., callbacks]): 添加在该
    Deferred 对象爆发进展公告时被调用的处理函数。
  • promise([target]): 返回 Deferred 对象的 promise 对象。
  • reject([argument, ..., argument]): 拒绝一个 Deferred
    对象并以指定的参数调用所有的failCallbacks处理函数。
  • rejectWith(context[, argument, ..., argument]): 拒绝一个 Deferred
    对象并在指定的上下文中以指定参数调用所有的failCallbacks处理函数。
  • resolve([argument, ..., argument]): 解析一个 Deferred
    对象并以指定的参数调用所有的 doneCallbackswith 处理函数。
  • resolveWith(context[, argument, ..., argument]): 解析一个 Deferred
    对象并在指定的上下文中以指定参数调用所有的doneCallbacks处理函数。
  • state(): 再次回到当前 Deferred 对象的场合。
  • then(resolvedCallback[, rejectedCallback[, progressCallback]]):
    添加在该 Deferred 对象被分析、拒绝或收取进展文告时被调用的处理函数

从以上那写方法的叙述中,我想出色强调一下 jQuery 文档和 ECMAScript
标准在术语上的例外。在 ECMAScript 中, 不论一个 promise 被成功
(fulfilled) 依旧被驳回 (rejected),大家都说它被解析 (resolved)
了。但是在 jQuery 的文档中,被分析那个词指的是 ECMAScript 标准中的达成(fulfilled) 状态。

是因为地方列出的方法太多, 这里无法一一详述。然则在下一节会有多少个显示
DeferredPromise用法的示范。第三个例证中大家会接纳Deferred
对象重写“ jQuery
的回调函数”这一节的代码。第一个例证里我会评释以前商量的生产者–消费者以此比喻。

1.回调函数往往写成函数参数的花样,导致函数的输入和出口卓殊混乱,整个程序的可阅读性差;
2.回调函数往往只能够指定一个,如若有三个操作,就必要改写回调函数。
3.全勤程序的运行流程被打乱,除错和调节的难度都对应增多。

由when方法发生的Promise对象,即便给定的Promise对象中有自由一个被拒绝,就马上拒绝由when生成的Promise对象,这样做的用意

利用 Deferred 依次执行 Ajax 请求

这一节我会利用Deferred目的和它提供的主意使“jQuery
的回调函数”这一节的代码更有着可读性。但在一头扎进代码从前,让我们先搞了解一件事:在
Deferred 对象共处的艺术中,大家需求的是什么样。

根据大家的要求及上文的主意列表,很肯定大家既可以用 done()也可以由此
then()来处理操作成功的意况,考虑到许五人早就见惯不惊了应用JS 的原生
Promise目的,那么些示例里自己会用 then()形式来落到实处。要留心 then()
done()那两者之间的一个根本不相同是
then()可见把接收到的值通过参数传递给后续的
then(),done(),fail()progress()调用。

因此最终大家的代码应该像上边那样:

JavaScript

var username = ‘testuser’; var fileToSearch = ‘README.md’;
$.getJSON(” + username + ‘/repositories’)
.then(function(repositories) { return repositories[0].name; })
.then(function(lastUpdatedRepository) { return
$.getJSON(” + username + ‘/repository/’ +
lastUpdatedRepository + ‘/files’); }) .then(function(files) { var README
= null; for (var i = 0; i < files.length; i++) { if
(files[i].name.indexOf(fileToSearch) >= 0) { README =
files[i].path; break; } } return README; }) .then(function(README) {
return $.getJSON(” + username +
‘/repository/’ + lastUpdatedRepository + ‘/file/’ + README +
‘/content’); }) .then(function(content) { console.log(content); });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var username = ‘testuser’;
var fileToSearch = ‘README.md’;
 
$.getJSON(‘https://api.github.com/user/’ + username + ‘/repositories’)
  .then(function(repositories) {
    return repositories[0].name;
  })
  .then(function(lastUpdatedRepository) {
    return $.getJSON(‘https://api.github.com/user/’ + username + ‘/repository/’ + lastUpdatedRepository + ‘/files’);
  })
  .then(function(files) {
    var README = null;
 
for (var i = 0; i < files.length; i++) {
      if (files[i].name.indexOf(fileToSearch) >= 0) {
        README = files[i].path;
 
break;
      }
    }
 
return README;
  })
  .then(function(README) {
    return $.getJSON(‘https://api.github.com/user/’ + username + ‘/repository/’ + lastUpdatedRepository + ‘/file/’ + README + ‘/content’);
  })
  .then(function(content) {
    console.log(content);
  });

如你所见,由于我们可以把一切操作拆分成同在一个缩进层级的逐一步骤,这段代码的可读性已经明确狠抓了。

Promises就是为了缓解这个题材而提议的,它的首要指标就是顶替回调函数,成为非同步操作的缓解方案。它的要旨情想就是让非同步操作重临一个目的,其他操作都对准这一个目的来成功。比如,假定ajax操作再次回到一个Promise对象。

 

成立一个基于 Promise 的 set提姆eout 函数

您或许曾经知晓
setTimeout()
函数能够在延迟一个加以的年华后举行某个回调函数,只要你把日子和回调函数作为参数传给它。即使你想要在一分钟后在控制台打印一条日志信息,你可以用它那样写:

JavaScript

setTimeout( function() { console.log(‘等待了1秒钟!’); }, 1000 );

1
2
3
4
5
6
setTimeout(
  function() {
    console.log(‘等待了1秒钟!’);
  },
  1000
);

如你所见,setTimeout的率先个参数是要推行的回调函数,第四个参数是以阿秒为单位的等候时间。这个函数数年以来运行非凡,但假诺现在你要求在
Deferred目的的方法链中引入一段时间的延时该咋做吧?

下边的代码浮现了何等用 jQuery 提供的 Promise对象创立一个基于 promise
setTimeout(). 为了已毕大家的目标,那里运用了 Deferred对象的
promise()方法。

代码如下:

JavaScript

function timeout(milliseconds) { //成立一个新Deferred var deferred =
$.Deferred(); // 在指定的飞秒数之后解析Deferred对象
set提姆eout(deferred.resolve, milliseconds); //
再次来到Deferred对象的Promise对象 return deferred.promise(); }
timeout(1000).then(function() { console.log(‘等待了1分钟!’); });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function timeout(milliseconds) {
  //创建一个新Deferred
  var deferred = $.Deferred();
 
// 在指定的毫秒数之后解析Deferred对象
  setTimeout(deferred.resolve, milliseconds);
 
// 返回Deferred对象的Promise对象
  return deferred.promise();
}
 
timeout(1000).then(function() {
  console.log(‘等待了1秒钟!’);
});

那段代码里定义了一个名为 timeout()的函数,它包裹在 JS 原生的
setTimeout()函数之外。

timeout()里, 创设了一个
Deferred目的来落实在延迟指定的阿秒数之后将 Deferred
对象解析(Resolve)的作用。那里
timeout()函数是值的生产者,因而它承受制造 Deferred目的并赶回
Promise对象。那样一来调用者(消费者)就无法再自由解析或拒绝 Deferred
对象。事实上,调用者只好通过 done()
fail()如此的格局来扩展值再次来到时要执行的函数。

复制代码 代码如下:

就像就是为着缓解那样一种须求:在指定的多少个异步事件都做到了,然后才能干自己想干的作业

jQuery 1.x/2.x同 jQuery3 的区别

在首先个例证里,大家应用
Deferred目的来搜寻名字包罗“README.md”的文件,
但并不曾考虑文件找不到的情事。那种气象可以被用作是操作败北,而当操作战败时,大家也许需要暂停调用链的实践并直接跳到程序结尾。很自然地,为了贯彻这一个目标,大家相应在找不到文件时抛出一个至极,并用
fail()函数来捕获它,就好像 Javascriopt 的 catch()的用法一样。

在听从 Promises/A 和 Promises/A+ 的库里(例如jQuery
3.x),抛出的非凡会被转换成一个闭门羹操作 (rejection),进而通过
fail()办法添加的挫败条件回调函数会被实践,且抛出的老大会作为参数传给这个函数。

在 jQuery 1.x 和 2.x中,
没有被抓获的不得了会搁浅程序的实践。那多个版本允许抛出的相当向上冒泡,一般最后会到达
window.onerror。而若是没有定义极度的处理程序,万分新闻就会被出示,同时程序也会截止运作。

为了更好的知晓这一表现上的区分,让大家看一下从我书里摘出来的这一段代码:

JavaScript

var deferred = $.Deferred(); deferred .then(function() { throw new
Error(‘一条错误音信’); }) .then( function() {
console.log(‘第三个成功条件函数’); }, function() {
console.log(‘第二个破产条件函数’); } ) .then( function() {
console.log(‘第四个成功条件函数’); }, function() {
console.log(‘第一个破产条件函数’); } ); deferred.resolve();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var deferred = $.Deferred();
deferred
  .then(function() {
    throw new Error(‘一条错误信息’);
  })
  .then(
    function() {
      console.log(‘第一个成功条件函数’);
    },
    function() {
      console.log(‘第一个失败条件函数’);
    }
  )
  .then(
    function() {
      console.log(‘第二个成功条件函数’);
    },
    function() {
      console.log(‘第二个失败条件函数’);
    }
  );
 
deferred.resolve();

jQuery 3.x 中, 这段代码会在控制台出口“第二个破产条件函数” 和
“第一个成功条件函数”。原因如同本人面前提到的,抛出万分后的场合会被转换成拒绝操作进而战败条件回调函数一定会被实施。其它,一旦那么些被处理(在那几个事例里被挫折条件回调函数传给了第四个then()),后边的中标条件函数就会被实践(那里是第两个
then()里的中标条件函数)。

在 jQuery 1.x 和 2.x
中,除了第三个函数(抛出荒唐分外的老大)之外没有此外函数会被实践,所以您只会在控制台里看到“未处理的要命:一条错误新闻。”

您可以到上边多个JSBin链接中查阅它们的举行结果的例外:

  • jQuery 1.x/2.x
  • jQuery 3

为了更好的改良它同 ECMAScript2015 的包容性,jQuery3.x 还给 Deferred
Promise目的扩充了一个叫做 catch()的新章程。它可以用来定义当
Deferred对象被拒绝或
Promise对象处于拒绝态时的处理函数。它的函数签名如下:

JavaScript

deferred.catch(rejectedCallback)

1
deferred.catch(rejectedCallback)

可以见到,那几个措施不过是
then(null, rejectedCallback)的一个快捷格局罢了。

var promise = get(”);

 

总结

这篇文章里自己介绍了 jQuery 完毕的 promises。Promises
让大家可以摆脱那多少个用来共同异步函数的令人抓狂的技术,同时幸免我们陷入深层次的回调嵌套之中。

除却出示一些演示,我还介绍了 jQuery 3 在同原生 promises
互操作性上所做的精雕细刻。固然大家强调了 jQuery 的老版本同ECMAScript2015 在
Promises
完成上有许多不一,Deferred对象依然是你工具箱里一件强有力的工具。作为一个职业开发人士,当项目的复杂度增加时,你会意识它总能派上用场。

打赏支持我翻译越多好小说,谢谢!

打赏译者

然后,Promise对象有一个then方法,可以用来指定回调函数。一旦非同步操作已毕,就调用指定的回调函数。

 

打赏帮助自己翻译更加多好小说,谢谢!

任选一种支付办法

亚洲必赢官网 1
亚洲必赢官网 2

1 赞 5 收藏
评论

复制代码 代码如下:

 

关于小编:HansDo

亚洲必赢官网 3

游走于Web前后端,平素在野路子上查找着。对绘画和数学有心无力(・-・*),尽其所能做一个劳动者。

个人主页 ·
我的篇章 ·
18 ·
   

亚洲必赢官网 4

promise.then(function (content) {
  console.log(content)
})

源码解析

可以将方面两段代码合并起来,那样程序的流程看得更驾驭。

 

复制代码 代码如下:

复制代码

get(‘ (content) {
  console.log(content)
})

jQuery.extend({

在1.7版以前,jQuery的Ajax操作使用回调函数。

    // Deferred helper

复制代码 代码如下:

    // 参数为Promise对象,大家誉为:给定的Promise对象

$.ajax({
    url:”/echo/json/”,
    success: function(response)
    {
       console.info(response.name);
    }
});

    // when函数内部的deferred对象,大家誉为:由when生成的Promise对象

1.7版之后,Ajax操作直接再次来到Promise对象,那意味着可以用then方法指定回调函数。

亚洲必赢官网,    when: function( subordinate /* , …, subordinateN */ ) {

复制代码 代码如下:

        var i = 0,

$.ajax({
    url: “/echo/json/”,
}).then(function (response) {
    console.info(response.name);
});

            resolveValues = core_slice.call( arguments ),

deferred对象的不二法门

            length = resolveValues.length,

$.deferred()方法

            // the count of uncompleted subordinates

作用是生成一个deferred对象。

            // 用来存储给定的未执行(解决)的Promise对象的个数

复制代码 代码如下:

            remaining = length !== 1 || ( subordinate &&
jQuery.isFunction( subordinate.promise ) ) ? length : 0,

var deferred = $.deferred();

 

done() 和 fail()

            // the master Deferred. If resolveValues consist of only a
single Deferred, just use that.

那五个主意都用来绑定回调函数。done()指定非同步操作成功后的回调函数,fail()指定战败后的回调函数。

            // 我们称deferred为when生成的Promise对象

复制代码 代码如下:

            deferred = remaining === 1 ? subordinate :
jQuery.Deferred(),

var deferred = $.Deferred();
deferred.done(function(value) {
   alert(value);
});

 

它们再次来到的是原本的deferred对象,由此得以拔取链式写法,在背后再链接其余措施(包罗done和fail在内)。

            // Update function for both resolve and progress values

resolve() 和 reject()

            updateFunc = function( i, contexts, values ) {

那七个格局用来改变deferred对象的情景。resolve()将状态改为非同步操作成功,reject()改为操作败北。

                return function( value ) {

复制代码 代码如下:

                    contexts[ i ] = this;

var deferred = $.Deferred();
deferred.done(function(value) {
   alert(value);
});
deferred.resolve(“hello world”);

                    values[ i ] = arguments.length > 1 ?
core_slice.call( arguments ) : value;

比方调用resolve(),就会相继执行done()和then()方法指定的回调函数;一旦调用reject(),就会相继执行fail()和then()方法指定的回调函数。

                    //
若是给定的轻易一个Promise对象未履行或拒绝,则文告由when生成的Promise对象为pending状态

state方法

                    // 注:contexts是由所有给定的Promise对象组成的数组,

该办法用来回到deferred对象如今的状态。

                    //
values是由拍卖所有给定的Promise对象的回调的参数组成的数组

复制代码 代码如下:

                    if( values === progressValues ) {

var deferred = new $.Deferred();
deferred.state();  // “pending”
deferred.resolve();
deferred.state();  // “resolved”

                        deferred.notifyWith( contexts, values );

该形式的再次回到值有七个:

                    }

1.pending:表示操作还未曾水到渠成。
2.resolved:表示操作成功。
3.rejected:表示操作失败。

                    //
如若给定的Promise对象已执行(解决),且当未履行的Promise对象个数为0,

notify() 和 progress()

                    //
即:给定的所有Promise对象都已执行(解决),则登时施行由when生成的Promise对象

progress()用来指定一个回调函数,当调用notify()方法时,该回调函数将推行。它的来意是提供一个接口,使得在非同步操作实施进程中,可以进行某些操作,比如定期回去进程条的进程。

                    // 注:contexts是由拥有给定的Promise对象组成的数组,

复制代码 代码如下:

                    //
values是由拍卖所有给定的Promise对象的回调的参数组成的数组(请看实例1)

 var userProgress = $.Deferred();
    var $profileFields = $(“input”);
    var totalFields = $profileFields.length
    userProgress.progress(function (filledFields) {
        var pctComplete = (filledFields/totalFields)*100;
        $(“#progress”).html(pctComplete.toFixed(0));
    });
    userProgress.done(function () {
        $(“#thanks”).html(“Thanks for completing your
profile!”).show();
    });
    $(“input”).on(“change”, function () {
        var filledFields =
$profileFields.filter(“[value!=”]”).length;
        userProgress.notify(filledFields);
        if (filledFields == totalFields) {
            userProgress.resolve();
        }
    });

                    else if ( !( –remaining ) ) {

then()

                        deferred.resolveWith( contexts, values );

then()的功能也是点名回调函数,它可以承受多个参数,也就是三个回调函数。第三个参数是resolve时调用的回调函数,第三个参数是reject时调用的回调函数,第两个参数是progress()方法调用的回调函数。

                    }

复制代码 代码如下:

                };

deferred.then( doneFilter [, failFilter ] [, progressFilter ] )

            },

在jQuery
1.8事先,then()只是.done().fail()写法的语法糖,三种写法是等价的。在jQuery
1.8之后,then()重回一个新的deferred对象,而done()再次回到的是固有的deferred对象。若是then()指定的回调函数有重临值,该重临值会作为参数,传入前边的回调函数。

 

复制代码 代码如下:

            progressValues, progressContexts, resolveContexts;

var defer = jQuery.Deferred();
defer.done(function(a,b){
            return a * b;
}).done(function( result ) {
            console.log(“result = ” + result);
}).then(function( a, b ) {
            return a * b;
}).done(function( result ) {
            console.log(“result = ” + result);
}).then(function( a, b ) {
            return a * b;
}).done(function( result ) {
            console.log(“result = ” + result);
});
defer.resolve( 2, 3 );

 

在jQuery 1.8版本从前,上边代码的结果是:

        // add listeners to Deferred subordinates; treat others as
resolved

复制代码 代码如下:

        if ( length > 1 ) {

result = 2
result = 2
result = 2

            progressValues = new Array( length );

在jQuery 1.8版本之后,再次来到结果是

            progressContexts = new Array( length );

复制代码 代码如下:

 

result = 2
result = 6
result = NaN

            // resolveValues = core_slice.call( arguments ) //
别忘了最上边的那行代码

那或多或少内需专门引起注意。

            resolveContexts = new Array( length );

复制代码 代码如下:

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

$.ajax( url1, { dataType: “json” } )
.then(function( data ) {
    return $.ajax( url2, { data: { user: data.userId } } );
}).done(function( data ) {
  // 从url2得到的数量
});

                //
如果给定when的参数是一个Promise对象,则文告由when生成的Promise对象,布告什么,如何打招呼?

上面代码最终那多少个done方法,处理的是从url2获取的数额,而不是从url1收获的多少。

                //
倘若给定的Promise对象已推行,则执行由when生成的Promise对象(要等到具备给定Promise对象全体实施)

采纳then()会修改重临值那几个特性,大家可以在调用其余回调函数从前,对前一步操作再次回到的值举办拍卖。

                //
若是给定的随意一个Promise对象已拒绝,则拒绝由when生成的Promise对象

复制代码 代码如下:

                // 若是未履行或拒绝,默许是pending状态

var post = $.post(“/echo/json/”)
    .then(function(p){
        return p.firstName;
    });
post.done(function(r){ console.log(r); });

                if ( resolveValues[ i ] && jQuery.isFunction(
resolveValues[ i ].promise ) ) {

地方代码先使用then()方法,从重回的数额中取出所必要的字段(firstName),所之前边的操作就可以只处理那些字段了。

                    resolveValues[ i ].promise()

偶尔,Ajax操作重回json字符串里面有一个error属性,表示发生错误。那么些时候,传统的方法只可以是透过done()来判断是还是不是暴发错误。通过then()方法,可以让deferred对象调用fail()方法。

                        .done( updateFunc( i, resolveContexts,
resolveValues ) )

复制代码 代码如下:

                        .fail( deferred.reject )

var myDeferred = $.post(‘/echo/json/’,
{json:JSON.stringify({‘error’:true})})
    .then(function (response) {
            if (response.error) {
                return $.Deferred().reject(response);
            }
            return response;
        },function () {
            return $.Deferred().reject({error:true});
        }
    );
myDeferred.done(function (response) {
        $(“#status”).html(“Success!”);
    }).fail(function (response) {
        $(“#status”).html(“An error occurred”);
    });

                        .progress( updateFunc( i, progressContexts,
progressValues ) );

always()

                }

always()也是点名回调函数,不管是resolve或reject都要调用。

                // 即使给定的不是一个Promise对象,那么负责减一

pipe方法

                else {

pipe方法接受一个函数作为参数,表示在调用then方法、done方法、fail方法、always方法指定的回调函数此前,先运行pipe方法指定的回调函数。它一般用来对服务器再次来到的数量做始发处理。

                    –remaining;

promise对象

                }

半数以上场地下,大家不想让用户从外表更改deferred对象的情景。那时,你能够在deferred对象的根底上,再次来到一个针对它的promise对象。大家得以把后者驾驭成,promise是deferred的只读版,或者更通俗地精通成promise是一个对即将完毕的天职的答应。

            }

您可以因此promise对象,为原本的deferred对象添加回调函数,查询它的情况,但是不可能改观它的情景,也就是说promise对象不容许你调用resolve和reject方法。

        }

复制代码 代码如下:

 

function getPromise(){
    return $.Deferred().promise();
}
try{
    getPromise().resolve(“a”);
} catch(err) {
    console.log(err);
}

        // if we’re not waiting on anything, resolve the master

上边的代码会出错,突显TypeError {} 。

        //
若是传递给when的参数都不是递延对象,则履行由when生成的Promise对象

jQuery的ajax()
方法重回的就是一个promise对象。其它,Animation类操作也得以动用promise对象。

        if ( !remaining ) {

复制代码 代码如下:

            // resolveContexts为一个空数组new Array( length
),resolveValues是由when参数组成的一个数组

var promise = $(‘div.alert’).fadeIn().promise();

            deferred.resolveWith( resolveContexts, resolveValues );

$.when()方法

        }

$.when()接受七个deferred对象作为参数,当它们整个运作成功后,才调用resolved状态的回调函数,但万一其中有一个告负,就调用rejected状态的回调函数。它一定于将三个非同步操作,合并成一个。

 

复制代码 代码如下:

        return deferred.promise();

$.when(
    $.ajax( “/main.php” ),
    $.ajax( “/modules.php” ),
    $.ajax( “/lists.php” )
).then(successFunc, failureFunc);

    }

地方代码表示,要等到五个ajax操作都截至之后,才实施then方法指定的回调函数。

});

when方法里面要推行多少个操作,回调函数就有些许个参数,对应后面每一个操作的归来结果。

复制代码

复制代码 代码如下:

 

$.when(
    $.ajax( “/main.php” ),
    $.ajax( “/modules.php” ),
    $.ajax( “/lists.php” )
).then(function (resp1, resp2, resp3){
    console.log(resp1);
    console.log(resp2);
    console.log(resp3);
});

 

位置代码的回调函数有多少个参数,resp1、resp2和resp3,依次对应前边多少个ajax操作的回到结果。

实例:关于实践由when生成的Promise对象的参数的题材

when方法的另一个效果是,如若它的参数重返的不是一个Deferred或Promise对象,那么when方法的回调函数将
立时运行。

 

复制代码 代码如下:

复制代码

$.when({testing: 123}).done(function (x){
  console.log(x.testing); // “123”
});

var promiseA = $.Deferred();

上面代码中指定的回调函数,将在when方法后边霎时运行。

var promiseB = $.Deferred();

选取那一个特性,大家可以写一个拥有缓存效果的异步操作函数。也就是说,第四遍调用那么些函数的时候,将实施异步操作,前面再调用那一个函数,将会重返缓存的结果。

 

复制代码 代码如下:

var doneFn = function(arg){

function maybeAsync( num ) {
  var dfd = $.Deferred();
  if ( num === 1 ) {
    setTimeout(function() {
      dfd.resolve( num );
    }, 100);
    return dfd.promise();
  }
  return num;
}
$.when(maybeAsync(1)).then(function (resp){
  $(‘#target’).append(‘<p>’ + resp + ‘</p>’);
});
$.when(maybeAsync(0)).then(function (resp){
  $(‘#target’).append( ‘<p>’ + resp + ‘</p>’);
});

    console.log(arg);

地点代码表示,假若maybeAsync函数的参数为1,则执行异步操作,否则即刻回到缓存的结果。

};

实例

 

wait方法

promiseA.done(doneFn);

俺们可以用deferred对象写一个wait方法,表示等待多少飞秒后再举办。

promiseB.done(doneFn);

复制代码 代码如下:

 

$.wait = function(time) {
  return $.Deferred(function(dfd) {
    setTimeout(dfd.resolve, time);
  });
}

promiseA.resolve(‘A’); // ‘A’

选取方法如下:

promiseB.resolve(‘B’); // ‘B’

复制代码 代码如下:

 

$.wait(5000).then(function() {
  alert(“Hello from the future!”);
});

var whenFn = function(arg1, arg2){

改写setTimeout方法

    console.log(this[0] === promiseA.promise()); // true

在上面的wait方法的功底上,仍是可以改写set提姆eout方法,让其回到一个deferred对象。

    console.log(this[1] === promiseB.promise()); // true

复制代码 代码如下:

    console.log(‘promise’ + arg1 + ‘, promise’ + arg2 + ‘ All done!’);

function doSomethingLater(fn, time) {
  var dfd = $.Deferred();
  setTimeout(function() {
    dfd.resolve(fn());
  }, time || 0);
  return dfd.promise();
}
var promise = doSomethingLater(function (){
  console.log( ‘已经延期执行’ );
}, 100);

};

自定义操作使用deferred接口

var whenPromise = jQuery.when(promiseA, promiseB);

大家可以运用deferred接口,使得任意操作都可以用done()和fail()指定回调函数。

whenPromise.done(whenFn); // true true ‘promiseA, promiseB All done!’

复制代码 代码如下:

复制代码

Twitter = {
  search:function(query) {
    var dfr = $.Deferred();
    $.ajax({
     url:””,
     data:{q:query},
     dataType:’jsonp’,
     success:dfr.resolve
    });
    return dfr.promise();
  }
}

 

选拔方法如下:

 

复制代码 代码如下:

jQuery回调、递延对象统计:

Twitter.search(‘intridea’).then(function(data) {
  alert(data.results[0].text);
});

 

deferred对象的另一个优势是能够叠加八个回调函数。

递延对象中的then方法效果于使多个异步任务根据顺序执行,而jQuery.when方法效果于在多个冒出的异步义务履行完成后再干自己感兴趣的作业;

复制代码 代码如下:

 

function doSomething(arg) {
  var dfr = $.Deferred();
  setTimeout(function() {
    dfr.reject(“Sorry, something went wrong.”);
  });
  return dfr;
}
doSomething(“uh oh”).done(function() {
  alert(“Won’t happen, we’re erroring here!”);
}).fail(function(message) {
  alert(message)
});

jQuery递延对象是按照jQuery回调对象架构的,即使您想熟谙驾驭jQuery递延对象,请先活动jQuery.Callbacks对象

您可能感兴趣的小说:

  • jQuery的deferred对象使用详解
  • jQuery
    Deferred和Promise创造响应式应用程序详细介绍
  • 利用jQuery的deferred对象落成异步按顺序加载JS文件
  • jQuery源码分析-05异步队列 Deferred
    使用介绍
  • jQuery $.extend()用法总括
  • jQuery插件开发的二种办法及$.fn.extend的详解
  • jQuery.extend 函数详解
  • 原生js完毕复制对象、增加对象
    类似jquery中的extend()方法
  • jQuery.extend()的落到实处形式详解及实例
  • jQuery中的deferred对象和extend方法详解

)
执行jQuery.when将会回来一个Promise对象,大家称为由when生成的Promise对象,如果给定的具有Promise对象均已执行,就应声施行
由…

网站地图xml地图