读jQuery源码 - Deferred

       var resolve = function () {
                console.log(‘成功‘);
            },
            //定义一个失败状态下运行的函数
            reject = function () {
                console.log(‘失败‘);
            };
            //模拟服务器请求，正在等待服务器响应ing.....
            setTimeout(function (status) {
                if (status === 200) resolve();
                else reject();
            }, 1000);

        var deferred = new Deferred();
            //先将成功和失败的函数委托到Deferred
            deferred.resolve(function () {
                console.log(‘成功‘);
            }).reject(function () {
                console.log(‘失败‘);
            }).resolve(function () {
                console.log(‘我还想再追加一个成功的函数‘);
            });
            //当改变状态的时候，会自动触发成或者失败的函数
            setTimeout(function (status) {
                if (status === 200) deferred.resolve();
                else deferred.reject();
            });    

       (function () {
            //Deferred的done/resolve
            var deferred = $.Deferred();
            deferred.done(function (state) {
                console.log(state); //write 1
            });
            resolve.resolve(1);
        } ());
        ~function () {
            //Deferred的fail/reject
            var deferred = $.Deferred();
            deferred.fail(function (state) {
                console.log(state); //write 2
            });
            resolve.reject(2);
        } ();
        !function () {
            //Deferred的progress/notify
            /*
            progress/notify对应的是“无状态”的状态
            它表示一个既不表示成功，也不表示失败的状态
            它每一次的触发（notify）都会执行progress里面的函数
            和resolve、reject不同，通过progress委托的函数，每次notify都不会被清空
            它可以反复被执行，用于会话保持
            */
            var deferred = $.Deferred();
            progress.progress(function (state) {
                console.log(state); //write 2
            });
            setTimeout(function () {
                //每隔1s反复执行
                resolve.notify(2);
            }, 1000);
        } ();

//jQuery.Deferred结构代码
        jQuery.extend({
            Deferred: function (func) {
                var tuples = [
                    ["resolve", "done", jQuery.Callbacks("once memory"), "resolved"],
                    ["reject", "fail", jQuery.Callbacks("once memory"), "rejected"],
                    ["notify", "progress", jQuery.Callbacks("memory")]
                ],
                state = "pending",
                promise = {
                    state: function () {
                        return state;
                    },
                    always: function () {
                        //直接调用
                        deferred.done(arguments).fail(arguments);
                        return this;
                    },
                    //then方法稍后解读
                    then: function ( /* fnDone, fnFail, fnProgress */) { },
                    promise: function (obj) {
                        return obj != null ? jQuery.extend(obj, promise) : promise;
                    }
                },
                deferred = {};
                //过去pipe，现在的then
                promise.pipe = promise.then;
                jQuery.each(tuples, function (i, tuple) {
                    var list = tuple[2],
                    stateString = tuple[3];
                    promise[tuple[1]] = list.add;
                    //内部先压入三个函数
                    if (stateString) {
                        list.add(function () {
                            state = stateString;
                            //把互斥的函数和无状态函数都给禁用掉
                        }, tuples[i ^ 1][2].disable, tuples[2][2].lock);
                    }
                    //resolve/reject/notify
                    deferred[tuple[0]] = function () {
                        //这里的this===deferred为什么做这一层判定没有理解
                        //这些触发状态的方法只能是deferred拥有，既然是deferred的触发，那么为何又要阉割当前上下文呢？
                        deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments);
                        return this;
                    };
                    //resolveWith/rejectWith/notifyWith
                    deferred[tuple[0] + "With"] = list.fireWith;
                });
                //promise有参方法是扩展这个参数
                promise.promise(deferred);

                //配合then使用的
                if (func) {
                    func.call(deferred, deferred);
                }
                return deferred;
            }
        });