jquery 中的deffered和promise对象方法及$when done then的使用

最新推荐文章于 2021-08-05 23:40:57 发布

ssisse

最新推荐文章于 2021-08-05 23:40:57 发布

阅读量5.5k

点赞数

分类专栏： jQuery JavaScript

JavaScript 同时被 2 个专栏收录

99 篇文章 2 订阅

订阅专栏

jQuery

41 篇文章 0 订阅

订阅专栏

对于$.ajax请求来说，如果层级比较多，程序看起来会比较乱，而为了解决这种问题，才有了$when...done...fail...then的封装，它将$.ajax这嵌套结构转成了顺序平行的结果，向下面的$.ajax写法，看起来很乱

$.ajax({
url: "/home/GetProduct",
dataType: "JSON",
type: "GET",
success: function (data) {
$.ajax({
url: "/home/GetProduct",
dataType: "JSON",
type: "GET",
success: function (data) {
$.ajax({
url: "/home/GetProduct",
dataType: "JSON",
type: "GET",
success: function (data) {
}
}
}

而它实现的功能无非就是外层执行完成后，去执行内层的代码代码，看下面的$.when写法，就清晰多了

$.when($.ajax({
url: "/home/GetProduct",
dataType: "JSON",
type: "GET",
success: function (data) {
alert(JSON.stringify(data));
}
})).done(function (data) {
alert(data[0].Name);
}).done(function (data) {
alert(data[1].Name);
}).fail(function () {
alert("程序出现错误！");
}).then(function (data) {
alert("程序执行完成");
});

而对于这种ajax的封装，在比较流行的node.js里也需要被看到，这就类似于方法的回调技术

下面通过一个例子再给大家介绍jquery when then(done) 用法

//运行条件jquery 1.82以上，直接运行代码，看结果

var log = function(msg){ 
window.console && console.log(msg) 
} 
function asyncThing1(){ 
var dfd = $.Deferred(); 
setTimeout(function(){ 
log('asyncThing1 seems to be done...'); 
dfd.resolve('1111'); 
},1000); 
return dfd.promise(); 
} 
function asyncThing2(){ 
var dfd = $.Deferred(); 
setTimeout(function(){ 
log('asyncThing2 seems to be done...'); 
dfd.resolve('222'); 
},1500); 
return dfd.promise(); 
} 
function asyncThing3(){ 
var dfd = $.Deferred(); 
setTimeout(function(){ 
log('asyncThing3 seems to be done...'); 
dfd.resolve('333'); 
},2000); 
return dfd.promise(); 
} 
/* do it */
$.when( asyncThing1(), asyncThing2(), asyncThing3() ).done(function(res1, res2, res3){ 
log('all done!'); 
log(res1 + ', ' + res2 + ', ' + res3); 
})

如果AJAX请求之间存在依赖关系，我们的代码就会形成Pyramid of Doom（金字塔厄运）。比如我们要完成这样一件事：有4个供Ajax访问的url地址，需要先Ajax访问第1个，在第1个访问完成后，用拿到的返回数据作为参数再访问第2个，第2个访问完成后再第3个...以此到4个全部访问完成。按照这样的写法，似乎会变成这样：

$.ajax({  
    url: url1,  
    success: function(data){  
        $.ajax({  
            url: url2,  
            data: data,  
            success: function(data){  
                $.ajax({  
                    //...  
                });  
            }      
        });  
    }  
});

1.Deferred.then()相当于Deferred.done()、Deferred.fail()、Deferred.progress()的合体，可以同时注册3个状态下的回调函数。

function success(data)
{
    alert(success data =  + data);
}
 
function fail(data)
{
    alert(fail data =  + data);
}
 
function progress(data)
{
    alert(progress data =  + data);
}
 
var deferred = $.Deferred();
 
// 一起注册回调
deferred.then(success, fail, progress);
 
// 分别注册回调
deferred.done(success);
deferred.fail(fail);
deferred.progress(progress);
 
deferred.notify(10%);
deferred.resolve(ok);

当然我们也可以像done()一样，多次调用then()注册回调函数。then()虽然可以这么使用，但是实际开发中一般不这么用，因为没有啥必要。JQuery1.8之前，这就是then()方法的作用。

2.Deferred.then()解决多个异步操作之间有依赖的问题，这才是then()真正有意义的场景。JQuery1.8之后，then()取代了过时的pipe()方法。这种场景下，我们需要使用Deferred.then()返回的新Promise对象。上面的第一种使用方式，我们忽略了Deferred.then()的返回值。

var deferred = $.Deferred();
 
// 使用then()注册一个resolved状态的回调函数,并返回一个过滤后的promise
// 返回的filtered已经不是原来的Deferred或者Promise对象了
var filtered = deferred.then(function( value ) {
                alert(trigger Deferred filter.value=+value);//5
                return value * 2;
            });
 
// 用过滤后的Promise再次注册回调函数         
filtered.done(function( value ) {
    alert(filtered value= + value);//10
});
  
deferred.resolve( 5 );

我们用deferred.then()注册了一个完成状态下的回调函数，这个回调函数得到的值是5；之后用filtered这个新的Promise注册回调函数，这个回调函数中得到的值是10(第一个回调函数的返回结果)。
我们知道deferred.resolve()、deferred.reject()、deferred.notify()可以指定参数值，这个参数会传递给相应状态下的回调函数。如果我们使用的是done()、fail()、progress()注册的回调函数，那么某个状态下的所有回调函数得到的都是相同参数。但是如果我们使用了then()注册回调函数，那么第一回调函数的返回值将作为第二个回调函数的参数，同样的第二个函数的返回值是第三个回调函数的参数。可以对比下面的2段代码，体会下done()和then的差别。

var deferred = $.Deferred();
 
// done()返回的仍然是原来的Deferred对象
var done_ret = deferred.done(function(data){
    alert(data=+data);//5
    return 2 * data;
});
alert(deferred == done_ret);//true
 
done_ret.done(function(data){
    alert(data=+data);//5
});
 
deferred.resolve( 5 );

var deferred = $.Deferred();
 
// then()返回的是一个新Promise对象
//then注册的回调函数的返回值将作为这个新Promise的参数
var then_ret = deferred.then(function(data){
    alert(data=+data);//5
    return 2 * data;
});
alert(then_ret == deferred);//false
 
then_ret.done(function(data){
    alert(data=+data);//10
});
 
deferred.resolve( 5 );

同样地，Deferred.then也能够实现rejected和pending状态的回调函数过滤。

var defer = $.Deferred();
var filtered = defer.then( null, function( value ) {
    return value * 3;
  });
  defer.reject( 6 );
 filtered.fail(function( value ) {
  alert( Value is ( 3*6 = ) 18:  + value );
});

下面这段代码可以实现chain tasks，解决异步操作中回调难的问题。

var defered = $.Deferred();
 var promise1 = defered.then(function(data){
    alert(data);//
    return data+=1;
});
 var promise2 = promise1.then(function(data){
    alert(data);//1
    return data+=2;
});
 var promise3 = promise2.then(function(data){
    alert(data);//12
    return data+=3;
});
 promise3.done(function(data){
    alert(data);//123
});
 defered.resolve();

正是由于then()这个特性，我们就可以上面复杂的AJAX嵌套改成如下形式:

var promise1 = $.ajax(url1);
var promise2 = promise1.then(function(data){
    return $.ajax(url2, { data: data });
});
var promise3 = promise2.then(function(data){
    return $.ajax(url3, { data: data });
});
promise3.done(function(data){
    // data retrieved from url3
});

二、示例

以前写动画时，我们通常是这么干的：

$('.animateEle').animate({
  opacity:'.5'
}, 4000,function(){
  $('.animateEle2').animate({
    width:'100px'
  },2000,function(){
    // 这样太伤了
    $('.animateEle3').animate({
      height:'0'
    },2000);
  });
});

假如这么使用回调的话，那就太伤了。幸好，还有一些现成的 Promise 解决方案来优雅地解决这种问题。

我们看看 jQuery 提供的解决办法。

var animate1 = function() {
  return $('.animateEle1').animate({opacity:'.5'},4000).promise();
};
var animate2 = function() {
  return $('.animateEle2').animate({width:'100px'},2000).promise();
};
var animate3 = function(){
  return $('.animateEle3').animate({height:'0'},2000).promise();
};
// so easy,有木有，so clear，有木有
$.when(animate1()).then(animate2).then(animate3);

很明显，更改后的代码更易懂易读了。

但是，上面的代码，有些细节的东西并没有透露，一不小心，就容易出错，得不到我们想要的顺序完成动画的效果。下面让我们来全面理解 jQuery 提供的 promise 和deferred 对象的方法，看看到底如何使用。

三、promise和deffered对象方法

promise 对象其实就是 deferred 对象的特例，因为 promise 对象不能更改异步状态，而 deferred 对象可以。这点在他们的方法设计上，有着明显的体现。

1.promise对象方法

通常，对于DOM，动画，ajax相关方法，我们都可以使用 promise 方法。调用 promise 方法，返回的是 promise 对象。可以链式调用 promise 方法。

promise对象常见的方法有三个： done ， fail ， then 。

其它的方法就不要去记了， jquery 这里的接口方法太多了，在我看来挺啰嗦的，就跟早期的事件方法绑定一样， live ， delegate ， bind ，最终不是都归为on 来管了么。

代码示例，如下：

1.DOM使用 promise 方法：

var box=$('#box');
box.promise().done(function(ele){
    console.log(ele);//jQuery box
});

2.Ajax使用 promise 方法(默认返回一个 promise 对象，所以可以不必显式调用 promise 方法)：

$.post('/',{}).done(function(data){
    console.log('请求成功');
}).fail(function(){
    console.log('请求错误');
});

动画示例已有，就不重复列出了。

2.deferred对象方法

对于 deferred 对象呢，也就是使用 $.Deferred() 方法，以及 $.when() 等方法创造出来的对象，有如下的常用方法：

resolve , reject , notify ;
done , fail , progress ;

另外还有 promise 、 then 和 always 方法。

之所以这么排版，是因为他们是对应的，也就是说： resolve 方法会触发 done 的回调执行， reject 会触发 fail 的回调， notify 会触发 progress 的回调。

直接看代码：

var wait = function(ms) {
  var dtd = $.Deferred();
  setTimeout(dtd.resolve, ms);
  // setTimeout(dtd.reject, ms);
  // setTimeout(dtd.notify, ms);
  return dtd.promise(); //此处也可以直接返回dtd
};

wait(2500).done(function() {
  console.log('haha,师太，你可让老衲久等了');
}).fail(function() {
  console.log('失败了');
}).progress(function(res) {
  console.log('等待中...');
});

我们看到了，上面的代码中，在 wait 函数中，返回的是个 promise 对象，而不是deferred 对象。

要知道， promise 对象是没有 resolve , reject , notify 等方法的，也就意味着，你无法针对 promise 对象进行状态更改，只能在 done 或 fail 中进行回调配置。所以，你如果这么调用 wait(2500).resolve() 将会报错，因为 wait(2500) 返回的是个 promise 对象，不存在 resolve 方法。

但是，这么做，有个好处，我们把 dtd 这个 deferred 对象放在了 wai t函数中，作为了局部变量，避免了全局的污染；进一步通过 promise 方法，转化 dtd 这个 deferred 对象为 promise 对象，避免了函数 wait 外部可能发生的状态更改（假如我们确实有这个需求）。

比如：

var wait = function(ms) {
  var dtd = $.Deferred();
  setTimeout(dtd.resolve, ms);
  // setTimeout(dtd.reject, ms);
  // setTimeout(dtd.notify, ms);
  return dtd; //此处也可以直接返回dtd
};

wait(2500).reject().fail(function(){
  console.log('失败了...............');
});

我们在外部更改了 wait 返回的 deferred 对象的状态，这样必然触发该对象的 fail 回调函数。

对于 always 方法，从字面意思上就很容易理解， deferred 对象无论是 resolve还是 reject ，都会触发该方法的回调。

3.其它共性

此处讲讲 then 和 $.when 方法的使用。它们对 promise 对象也适用。

$.when 方法接受多个 deferred 对象或者纯javascript对象，返回 promise 对象。
then 方法依次接受三个回调，分别为 deferred 对象 resolve , reject , notify 后触发的回调，返回一个 promise 对象。注意，必须传入函数，而该函数只有返回一个 promise 对象，才能够让异步事件按照预期顺序来执行。

我们来看看最开始的动画示例代码， $.when(animate1()).then(animate2).then(animate3) ， $.when 方法中接受了一个 animate1 的函数执行结果，也就是得到了一个 promise 对象，而后的 then 中，则只是接受了一个变量名，这样得到的结果是一个匿名的函数体，而该函数中返回的是 promise 对象。正好符合了我们对 then 接受参数的要求。

假如我们把执行语句改成： $.when(animate1()).then(animate2()).then(animate3()) ，这样造成的结果就是三个动画同步执行了。与 $.when(animate1(),animate2(),animate3()) 无异。

既然 then 是如此要求，那么与 then 方法类似的 done , fail , progress 也是一样的。

目前的ES标准中还未支持Promise对象，那么我们就自己动手，丰衣足食吧。思路大致是这样的，用2个数组(doneList和failList)分别存储成功时的回调函数队列和失败时的回调队列

state: 当前执行状态，有pending、resolved、rejected3种取值
done: 向doneList中添加一个成功回调函数
fail: 向failList中添加一个失败回调函数
then: 分别向doneList和failList中添加回调函数
always: 添加一个无论成功还是失败都会调用的回调函数
resolve: 将状态更改为resolved,并触发绑定的所有成功的回调函数
reject: 将状态更改为rejected,并触发绑定的所有失败的回调函数

when: 参数是多个异步或者延迟函数，返回值是一个Promise兑现，当所有函数都执行成功的时候执行该对象的resolve方法，反之执行该对象的reject方法
下面是我的具体实现过程：

var Promise = function() {
    this.doneList = [];
    this.failList = [];
    this.state = 'pending';
};

Promise.prototype = {
    constructor: 'Promise',
    resolve: function() {
        this.state = 'resolved';
        var list = this.doneList;
        for(var i = 0, len = list.length; i < len; i++) {
            list[0].call(this);
            list.shift();
        }
    },
    reject: function() {
        this.state = 'rejected';
        var list = this.failList;
        for(var i = 0, len = list.length; i < len; i++){
            list[0].call(this);
            list.shift();
        }
    },
    done: function(func) {
        if(typeof func === 'function') {
            this.doneList.push(func);
        }
        return this;
    },
    fail: function(func) {
        if(typeof func === 'function') {
            this.failList.push(func);
        }
        return this;
    },
    then: function(doneFn, failFn) {
        this.done(doneFn).fail(failFn);
        return this;
    },
    always: function(fn) {
        this.done(fn).fail(fn);
        return this;
    }
};

function when() {
    var p = new Promise();
    var success = true;
    var len = arguments.length;
    for(var i = 0; i < len; i++) {
        if(!(arguments[i] instanceof Promise)) {
            return false;
        }
        else {
            arguments[i].always(function() {
                if(this.state != 'resolved'){
                    success = false;
                }
                len--;
                if(len == 0) {
                    success ? p.resolve() : p.reject();
                }
            });
        }
    }
    return p;
}

转自：https://segmentfault.com/a/1190000000684654，

http://www.tuicool.com/articles/MVnmamr，

http://www.2cto.com/kf/201507/424202.html，

http://www.jb51.net/article/84690.htm

ssisse

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
jquery 中的deffered和promise对象方法及$when done then的使用

对于$.ajax请求来说，如果层级比较多，程序看起来会比较乱，而为了解决这种问题，才有了$when...done...fail...then的封装，它将$.ajax这嵌套结构转成了顺序平行的结果，向下面的$.ajax写法，看起来很乱$.ajax({url: "/home/GetProduct",dataType: "JSON",type: "GET",success: function (
复制链接

扫一扫