熟悉promise的同學(xué)應(yīng)該知道，每次then執(zhí)行完成后都是會(huì)默認(rèn)返回promis的，就是為了方便鏈?zhǔn)讲僮鳌?br>先貼上完整代碼：

var ref = function (value) {
    if (value && typeof value.then === "function")
        return value;
    return {
        then: function (callback) {
            return ref(callback(value));
        }
    };
};
var defer = function () {
    var pending = [], value;
    return {
        resolve: function (_value) {
            if (pending) {
                value = ref(_value); // values wrapped in a promise
                for (var i = 0, ii = pending.length; i < ii; i++) {
                    var callback = pending[i];
                    value.then(callback); // then called instead
                }
                pending = undefined;
            }
        },
        promise: {
            then: function (_callback) {
                var result = defer();
                // callback is wrapped so that its return
                // value is captured and used to resolve the promise
                // that "then" returns
                var callback = function (value) {
                    result.resolve(_callback(value));
                };
                if (pending) {
                    pending.push(callback);
                } else {
                    value.then(callback);
                }
                return result.promise;
            }
        }
    };
};

直接看是有點(diǎn)懵逼的。。
分開來看一下，先看這一段promise對(duì)象：

promise: {
    then: function (_callback) {
        var result = defer();
        // callback is wrapped so that its return
        // value is captured and used to resolve the promise
        // that "then" returns
        var callback = function (value) {
            result.resolve(_callback(value));
        };
        if (pending) {
            pending.push(callback);
        } else {
            value.then(callback);
        }
        return result.promise;
    }
}

鏈?zhǔn)讲僮鞯男问剑簒xx.then(callback1).then(callback2)

也就是說我們的then函數(shù)返回的是promise對(duì)象；

所以在then函數(shù)的開始， var result = defer();創(chuàng)建一個(gè)空promise對(duì)象。最后return result；

callback1在執(zhí)行后要把結(jié)果給callback2吧，怎么給呢？

先執(zhí)行回調(diào)：callback1(value)

執(zhí)行完了通知下一個(gè)promise可以執(zhí)行了：result.resolve()

合體：result.resolve(callback1(value))

再看這一段resolve函數(shù)：

 resolve: function (_value) {
    if (pending) {
        value = ref(_value); // values wrapped in a promise
        for (var i = 0, ii = pending.length; i < ii; i++) {
            var callback = pending[i];
            value.then(callback); // then called instead
        }
        pending = undefined;
    }
},

resolve(_value)中的_value是封裝者給回調(diào)的參數(shù)；

_value可能是一個(gè)promise嗎？當(dāng)然可以；

ref函數(shù)就是為了判斷_vlaue是不是promise，如果是則原樣返回，不是的話包裝成一個(gè)promise返回，方便我們統(tǒng)一處理；

經(jīng)過ref處理過的value肯定是一個(gè)promise了，所以我們統(tǒng)一寫成：value.then(callback)

貼一下ref:

var ref = function (value) {
    if (value && typeof value.then === "function")
        return value;
    return {
        then: function (callback) {
            return ref(callback(value));
        }
    };
};

這里看到，如果vlaue是promise，就直接返回；

value如果不是promise，包裝成promise，把value傳入callback；

所以ref只是作者抽出去的一個(gè)工具函數(shù)哈，其實(shí)不抽的話更容易看懂= =！
把ref合進(jìn)resolve，大家看看是不是容易理解了：

resolve: function (_value) {
    if (pending) {
        if(_value && typeof _value.then === "function") {
            for (var i = 0, ii = pending.length; i < ii; i++) {
                var callback = pending[i];
                _value.then(callback); 
            }
        }else {
            for (var i = 0, ii = pending.length; i < ii; i++) {
                pending[i](_value);
            }
        }
        pending = undefined;
    }
},

這種寫法沒有保存_value到value中,僅僅是為了解釋resolve的一段代碼

目前來看的話，promise只接受了一個(gè)回調(diào)，很明顯這里需要再接受一個(gè)錯(cuò)誤回調(diào)，根據(jù)異步操作的執(zhí)行結(jié)果，選擇執(zhí)行哪個(gè)。
先貼完整代碼：

var defer = function () {
    var pending = [], value;
    return {
        resolve: function (_value) {
            if (pending) {
                value = ref(_value);
                for (var i = 0, ii = pending.length; i < ii; i++) {
                    value.then.apply(value, pending[i]);
                }
                pending = undefined;
            }
        },
        promise: {
            then: function (_callback, _errback) {
                var result = defer();
                // provide default callbacks and errbacks
                _callback = _callback || function (value) {
                    // by default, forward fulfillment
                    return value;
                };
                _errback = _errback || function (reason) {
                    // by default, forward rejection
                    return reject(reason);
                };
                var callback = function (value) {
                    result.resolve(_callback(value));
                };
                var errback = function (reason) {
                    result.resolve(_errback(reason));
                };
                if (pending) {
                    pending.push([callback, errback]);
                } else {
                    value.then(callback, errback);
                }
                return result.promise;
            }
        }
    };
};
let ref = (value) => {
    if (value && typeof value.then === "function")
        return value;
    return {
        then: function (callback) {
            return ref(callback(value));
        }
    };
};

let reject = (reason) => {
    return {
        then: function (callback, errback) {
            return ref(errback(reason));
        }
    };
};

保證callbacks和errbacks在未來他們被調(diào)用的時(shí)候，應(yīng)該是和注冊(cè)時(shí)的順序是保持一致的。這將顯著降低異步編程中流程控制出錯(cuò)可能性。

let enqueue = (callback) => {
    setTimeout(callback,1)
}

 resolve: function (_value) {
    if (pending) {
        value = ref(_value);
        for (let i = 0, ii = pending.length; i < ii; i++) {
            enqueue(function () {
                value.then.apply(value, pending[i]);
            });
        }
        pending = undefined;
    }
}
        
let ref = function (value) {
    if (value && value.then)
        return value;
    return {
        then: function (callback) {
            let result = defer();
            // XXX
            enqueue(function () {
                result.resolve(callback(value));
            });
            return result.promise;
        }
    };
};

let reject = function (reason) {
    return {
        then: function (callback, errback) {
            var result = defer();
            // XXX
            enqueue(function () {
                result.resolve(errback(reason));
            });
            return result.promise;
        }
    };
};