自己照著Promise/A規(guī)范寫的Promise庫

Render 發(fā)布于2019-08-20 15:56 / 3594人閱讀

摘要：試圖寫了一下大概測試了一下沒有用專業(yè)的測試工具測試代碼感覺還是寫的比較好懂的，本人水平較差，如果測試有問題，歡迎回復(fù)指出地址同一執(zhí)行隊列中原生是先于實現(xiàn)的自己實現(xiàn)暫時用模擬必須傳入并且構(gòu)造狀態(tài)改變之后傳遞的值執(zhí)行之后返回的這里必須異步處理否

試圖寫了一下,大概測試了一下,沒有用專業(yè)的測試工具測試....

代碼感覺還是寫的比較好懂的，本人水平較差，如果測試有問題，歡迎回復(fù)指出
地址： https://github.com/julyL/Code...

(function(global) {
    function isFunction(val) {
        return typeof val == "function";
    }

    function isObject(val) {
        return typeof val == "object";
    }

    function asyncExcute(fn) {
        return function() {
            setTimeout(fn); // 同一執(zhí)行隊列中,原生Promise是先于setTimeout實現(xiàn)的,自己實現(xiàn)暫時用setTimeout模擬
        }
    }
    function Promise(fn) {
        if (!isFunction(fn) || this instanceof Promise == false) {
            throw new TypeError("Promise必須傳入function并且new構(gòu)造")
        }
        this.status = "pending";
        this.value = undefined; //  promise狀態(tài)改變之后傳遞的值
        this.thenPromise = undefined; //執(zhí)行then之后返回的promise
        this.resolveQueue = []; //
        this.rejectQueue = []; //   
        var re = asyncExcute(function(resolveData) { this._resolve(resolveData) }.bind(this)), //這里必須異步處理,否則then函數(shù)執(zhí)行以前可能就已經(jīng)執(zhí)行了_resolve,但這時then中函數(shù)還未加入resolveQueue中
            rj = asyncExcute(function(resolveData) { this._reject(resolveData) }.bind(this));
        try {
            fn(re, rj)
        } catch (error) {
            this.status = "reject";
            this.value = error;
            asyncExcute(function(){this._reject(error)});         //  new Promise(()=>{ 出現(xiàn)異常... }).then(refn,rjfn);    出現(xiàn)異常時then還未執(zhí)行, rjfn還未加入到rejectQueue中  
        }
    }
    Promise.prototype.then = function(refn, rjfn) {
        var returnPro = new Promise(function() {});
        this.thenPromise = returnPro;
        this.resolveQueue.push(refn);
        this.rejectQueue.push(rjfn);

        if (this.status == "resolve") { //執(zhí)行then時,如果狀態(tài)已經(jīng)不是pending,則執(zhí)行相應(yīng)函數(shù)
            this._resolve(this.value);
        }
        if (this.status == "reject") {
            this._reject(this.value);
        }
        return returnPro;
    }
    Promise.prototype._resolve = function(resolveData) {
        var handle,
            returnVal;
        this.status = "resolve";
        this.value = resolveData;
        while (this.resolveQueue.length > 0) { //2.2.6  當(dāng) promise 成功執(zhí)行時，所有 onFulfilled 需按照其注冊順序依次回調(diào)
            handle = this.resolveQueue.shift();
            if (!isFunction(handle)) { //不是函數(shù)  2.1.1 onFulfilled 不是函數(shù)，其必須被忽略
                this.thenPromise.value = resolveData;
                this.thenPromise.status = "resolve";
                this.thenPromise._resolve();
                return;
            }
            try { //如果 onFulfilled 或者 onRejected 拋出一個異常 e ，則 promise2 必須拒絕執(zhí)行，并返回拒因 e
                returnVal = handle(resolveData);
            } catch (error) {
                this.thenPromise.status = "reject";
                this.thenPromise.value = error;
                this.thenPromise._reject();
            }
            if (isObject(returnVal || isFunction(returnVal))) { //如果返回值為對象或者函數(shù)
                if (returnVal == this.thenPromise) { //如果 promise 和 x 指向同一對象，以 TypeError 為據(jù)因拒絕執(zhí)行 promise
                    this.thenPromise.status = "reject";
                    this.thenPromise.value = new TypeError("[[Resolve]](promise, x),promise 和 x 不能指向同一對象");
                } else if (returnVal instanceof Promise) { //如果 x 為 Promise ，則使 promise 接受 x 的狀態(tài)
                    try {
                        then.call(returnVal, this.thenPromise._resolve.bind(this.thenPromise), this.thenPromise._reject.bind(this.thenPromise));
                    } catch (error) {
                        this.thenPromise.status = "reject";
                        this.thenPromise.value = error;
                        this.thenPromise._reject();
                    }
                } else { //如果 x 為對象或者函數(shù)
                    try { //如果取 x.then 的值時拋出錯誤 e ，則以 e 為據(jù)因拒絕 promise
                        var then = returnVal.then;
                        if (isFunction(then)) {
                            then.call(returnVal, this.thenPromise._resolve.bind(this.thenPromise), this.thenPromise._reject.bind(this.thenPromise));
                        }
                    } catch (error) {
                        this.thenPromise.status = "reject";
                        this.thenPromise.value = error;
                        this.thenPromise._reject();
                    }
                }
            } else {
                this.thenPromise.value = returnVal;
                this.thenPromise.status = "resolve";
                this.thenPromise._resolve();
            }
        }
    }

    Promise.prototype._reject = function(resolveData) {
        var handle,
            returnVal;
        this.status = "resolve";
        this.value = resolveData;
        while (this.rejectQueue.length > 0) {     //2.2.6  當(dāng) promise 成功執(zhí)行時，所有 onFulfilled 需按照其注冊順序依次回調(diào)
            handle = this.rejectQueue.shift();
            if (!isFunction(handle)) {          //不是函數(shù)  2.1.1 onFulfilled 不是函數(shù)，其必須被忽略
                this.thenPromise.value = resolveData;
                this.thenPromise.status = "resolve";
                this.thenPromise._resolve();
                return;
            }
            try { //如果 onFulfilled 或者 onRejected 拋出一個異常 e ，則 promise2 必須拒絕執(zhí)行，并返回拒因 e
                returnVal = handle(resolveData);
            } catch (error) {
                this.thenPromise.status = "reject";
                this.thenPromise.value = error;
                this.thenPromise._reject();
            }
            if (isObject(returnVal || isFunction(returnVal))) { //如果返回值為對象或者函數(shù)
                if (returnVal == this.thenPromise) { //如果 promise 和 x 指向同一對象，以 TypeError 為據(jù)因拒絕執(zhí)行 promise
                    this.thenPromise.status = "reject";
                    this.thenPromise.value = new TypeError("[[Resolve]](promise, x),promise 和 x 不能指向同一對象");
                } else if (returnVal instanceof Promise) { //如果 x 為 Promise ，則使 promise 接受 x 的狀態(tài)
                    try {
                        then.call(returnVal, this.thenPromise._resolve.bind(this.thenPromise), this.thenPromise._reject.bind(this.thenPromise));
                    } catch (error) {
                        this.thenPromise.status = "reject";
                        this.thenPromise.value = error;
                        this.thenPromise._reject();
                    }
                } else {      //如果 x 為對象或者函數(shù)
                    try {     //如果取 x.then 的值時拋出錯誤 e ，則以 e 為據(jù)因拒絕 promise
                        var then = returnVal.then;
                        if (isFunction(then)) {
                            then.call(returnVal, this.thenPromise._resolve.bind(this.thenPromise), this.thenPromise._reject.bind(this.thenPromise));
                        }
                    } catch (error) {
                        this.thenPromise.status = "reject";
                        this.thenPromise.value = error;
                        this.thenPromise._reject();
                    }
                }
            } else {
                this.thenPromise.value = returnVal;
                this.thenPromise.status = "resolve";
                this.thenPromise._resolve();
            }
        }
    }

    Promise.resolve = function(value) {
        return new Promise(function(re, rj) {
            re(value)
        })
    }
    Promise.reject = function(value) {
        return new Promise(function(re, rj) {
            re(value)
        })
    }
    Promise.all = function(queue) {
        if (Object.prototype.toString.call(queue) != "[object Array]") {
            return;
        }
        var returnPromise = new Promise(function() {}),
            resolveNum = 0;
        for (var i = 0; i < queue.length; i++) {
            queue[i].then(function() {
                resolveNum++;
                if (resolveNum == queue.length) {
                    returnPromise._resolve();
                }
            });
        }
        return returnPromise;
    }
    Promise.race = function(queue) {
        if (Object.prototype.toString.call(queue) != "[object Array]") {
            return;
        }
        var returnPromise = new Promise(function() {}),
            resolveNum = 0;
        for (var i = 0; i < queue.length; i++) {
            queue[i].then(function() {
                returnPromise._resolve();
            });
        }
        return returnPromise;
    }
    global.Promise = Promise;
})(window);