Promise介绍--Deferred及jQuery篇

最近懒癌发做，说好的系列文章，写了一半，一直懒得写，今天补上一篇。

Deferred

咱们在使用promise对象时，总会提到一个与它关系密切的对象——Deferred。其实Deferred没什么内容可讲的，其实很简单。

• 它包含一个promise对象

• 它能够改变对应的promise的状态

简单的实现以下：

class Deferred{
    constructor(){
        let defer = {};
        defer.promise = new Promise((resolve, reject)=>{
            defer.resolve = resolve;
            defer.reject = reject;
        })
        return defer;
    }
}

咱们知道promise对象内部的状态，自己是在建立对象时传入的函数内控制，外部是访问不到的，Deferred对象在它的基础上包装了一层，并提供了两个在外部改变它状态的方法。

用法其实在Promise介绍--规范篇中的例子内，多处使用到了，这里就再也不赘述。总以为文章写这么点儿，就显得太水了。。因此借此，讲讲jQuery中的实现。

jQuery中还有一个静态方法$.Callbacks()，因为$.Deferred()强依赖它，因此咱们先从它开刀。

$.Callbacks()

$.Callbacks()咱们称为回调对象，它内部会维护一个数组，咱们能够向其中添加若干个回调函数，而后在某一条件下触发执行。

有几个方法从名字咱们就知道它的做用是什么，add向数组内部添加一个回调函数，empty清空数组，fire触发回调函数，has数组中是否已经添加某回调函数，remove从数组中删除某回调函数。

fireWith函数接收两个参数，第一个是回调函数执行的上下文，第二个是回传给回调函数的参数。fire中其实内部调用的就是fireWith，其中第一个参数传递的是this。

其它的几个函数，都和回调数组的状态有关。建立Callbacks对象时，接收一个字符串或者对象做为参数。其实内部都会转换为对象，这里不赘述，不一样字符串表示不一样的处理方式，一一介绍。

once ：对象只会调用一次。

let cb = $.Callbacks('once')
function a(){console.log('a')}
function b(){console.log('b')}
cb.add(a)
cb.fire()
cb.add(b)
cb.fire()
// a

第一次fire以后，回调列表以后不会再次触发。

memory ： 记住回调列表的执行状态，若是回调函数fire过一次，以后每次add以后，则自动触发该回调。

let cb = $.Callbacks('memory')
function a(){console.log('a')}
function b(){console.log('b')}
cb.add(a)
cb.fire()
// a
cb.add(b)
// b

第一次fire以后，再次add新的回调函数b时，自动执行回调b。

unique：每个回调函数只能够添加一次。

let cb = $.Callbacks('unique')
function a(){console.log('a')}
function b(){console.log('b')}
cb.add(a)
cb.add(a)
cb.fire()
// a
cb.add(b)
cb.fire()
// a
// b

第一次fire时，只会打印一个a，说明第二个a没有添加成功，但当咱们添加b时，是能够添加成功的。

stopOnFalse：当前面的回调函数返回false时，终止后面的回调继续执行。

let cb = $.Callbacks('stopOnFalse')
function a(){console.log('a');return false;}
function b(){console.log('b')}
cb.add(a)
cb.add(b)
cb.fire()
// a

函数a返回了false，致使函数b没有执行。

咱们再回过头看$.Callbacks()对象的方法，lock方法表示锁住回调数组，再也不执行，也就是模式为once时，调用一次fire后的状态，即在此以后不能够在此触发。以下：

let cb = $.Callbacks()
function a(){console.log('a')}
function b(){console.log('b')}
cb.add(a)
cb.fire()
cb.lock()
cb.add(b)
cb.fire()

lock以后，再次添加函数b并调用fire时，不会再次执行，与once模式下效果相似。但若是是memory模式，回调先fire，而后再lock，以后再次add时，新添加的函数依然会执行。

let cb = $.Callbacks('memory')
function a(){console.log('a')}
function b(){console.log('b')}
cb.add(a)
cb.fire()
cb.lock()
cb.add(b)
// a
// b

其实这种效果和直接建立回调对象时，参数设为once memory是一致的。也就是说，以下代码与上面效果一致。

let cb = $.Callbacks('once memory')
function a(){console.log('a')}
function b(){console.log('b')}
cb.add(a)
cb.fire()
cb.add(b)
// a
// b

咱们发现这种once memory模式，正好与Promise中then方法添加的回调很相似。若是promise对象处于pending状态，则then方法添加的回调存储在一个数组中，当promise对象状态改变(fire)时，执行相应的回调，且以后再次经过then方法添加回调函数，新回调会马上执行。同时，每个回调只能执行一次。因此，$.Deferred()内部用的正好是once memory的Callbacks。

还有一个函数叫作disable，它的做用是直接禁用掉这个回调对象，清空回调数组，禁掉fire、add等。

locked用于判断数组是否被锁住，返回true或false。disabled用于判断回调对象是否被警用，一样返回true或false。

$.Deferred()

有了以上的基础，咱们接下来看看jQuery中，Deferred对象的实现。咱们先看看它都有哪些方法。如图：

别的方法咱们暂且不关注，咱们注意到里面有四个咱们比较熟悉的方法，promise，reject，resolve。它们和咱们前面说的Deferred对象中做用差很少。

jQuery的Deferred中有三个添加回调函数的方法done，fail，progress，分别对应添加promise状态为resolved、rejected和pending时的回调，同时对应有三个触发回调函数的方法resolve、reject和notify。

咱们接下来看看它内部是怎么实现的。首先为每种状态分别建立一个Callbacks对象，以下：

var tuples = [
      // action, add listener, listener list, final state
     ["resolve", "done", jQuery.Callbacks("once memory"), "resolved"],
     ["reject", "fail", jQuery.Callbacks("once memory"), "rejected"],
     ["notify", "progress", jQuery.Callbacks("memory")]
]

咱们发现done、fail对应的回调对象是once memory，而progress对应的是memory。说明经过progress添加的函数，能够屡次重复调用。

而后定义了一个state用来保存状态，以及内部的一个promise对象。

state = "pending",
promise = {
    state: function() {
        return state;
    },
    always: function() {
        deferred.done(arguments).fail(arguments);
        return this;
    },
    then: function( /* fnDone, fnFail, fnProgress */ ) {
    },

    // Get a promise for this deferred
    // If obj is provided, the promise aspect is added to the object
    promise: function(obj) {
        return obj != null ? jQuery.extend(obj, promise) : promise;
    }
},

接下来会执行一个循环，以下：

// Add list-specific methods
jQuery.each(tuples, function(i, tuple) {
    var list = tuple[2],
        stateString = tuple[3];

    // promise[ done | fail | progress ] = list.add
    promise[tuple[1]] = list.add;

    // Handle state
    if (stateString) {
        list.add(function() {

            // state = [ resolved | rejected ]
            state = stateString;

            // [ reject_list | resolve_list ].disable; progress_list.lock
        }, tuples[i ^ 1][4].disable, tuples[2][5].lock);
    }

    // deferred[ resolve | reject | notify ]
    deferred[tuple[0]] = function() {
        deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments);
        return this;
    };
    deferred[tuple[0] + "With"] = list.fireWith;
});

这一段代码中咱们能够看出，done、fail、progress其实就是add，resolve、reject和notify其实就是fire，与之对应的resolveWith、rejectWith和notifyWith其实就是fireWith。且成功和失败的回调数组中，会预先添加一个函数，用来设置promise的状态和禁用掉其它状态下的回调对象。

从上面这段代码中咱们也能够看出，添加回调函数的方法，都是添加在promise对象上的，而触发回调的方法是添加在deferred对象上的。代码中会经过以下方法，把promise对象的方法合并到deferred对象上。

promise.promise(deferred);

因此，咱们打印一下$.Deferred().promise()。

发现它确实比$.Deferred()少了那几个触发回调的方法。

其它的几个方法咱们简单说一下，always会同时在成功和失败的回调数组中添加方法。state是查看当前promise对象的状态。

then方法以下：

then: function( /* fnDone, fnFail, fnProgress */ ) {
    var fns = arguments;
    return jQuery.Deferred(function(newDefer) {
        jQuery.each(tuples, function(i, tuple) {
            var fn = jQuery.isFunction(fns[i]) && fns[i];

            // deferred[ done | fail | progress ] for forwarding actions to newDefer
            deferred[tuple[1]](function() {
                var returned = fn && fn.apply(this, arguments);
                if (returned && jQuery.isFunction(returned.promise)) {
                    returned.promise()
                        .progress(newDefer.notify)
                        .done(newDefer.resolve)
                        .fail(newDefer.reject);
                } else {
                    newDefer[tuple[0] + "With"](
                        this === promise ? newDefer.promise() : this,
                        fn ? [returned] : arguments
                    );
                }
            });
        });
        fns = null;
    }).promise();
}

从代码中咱们能够看出，then方法和规范中的then方法相似，不过这里多了第三个参数，是用于给progress添加回调函数，同时返回一个新的promise对象。

pipe是为了向前兼容，它与then是相等的。

$.when()

jQuery中还有一个与之相关的方法$.when()，它的做用相似于Promise.all()。具体实现方式基本是新建了一个Deferred对象，而后遍历全部传递进去的promise对象。不过添加了progres的处理。总之和规范有不少的不一样，你们有兴趣的就本身看一下吧。