手寫Promise，分析流程

參考： juejin.im/post/5c88e4…

分爲三個模塊：

1： Promise函數
2： Promise.prototype.then
3:  resolvePromise
複製代碼

一:Promise函數

1：定義三種狀態
2：定義Promise函數，定義接收參數爲executor 執行器
3：定義this指向
4: 定義初始化狀態
5：定義成功/失敗時候的回調
6：定義resolve函數， 定義接收參數爲value
6.1：判斷初始狀態 ， 條件爲真改變狀態，同時定義值
6.2：對成功時候的回調進行遍歷循環執行
7：定義reject函數， 定義接收參數爲 reason
7.1：同6.1
7.2：同6.2 ， 對失敗時候的回調進行遍歷
8：嘗試執行執行器,執行器接收二個參數(resolve ,reject)， catch(e) reject(e)
複製代碼

二: Promise.prototype.then

1: 函數接收成功回調/失敗回調做爲參數
2：判斷回調是否爲函數
3：定義一個Promise2  = 實例化Promise，實例化時，Promise有三種狀態
4：判斷是否爲第一種狀態Fulfilled
4.1：在延遲器setTimeout 執行try-catch
4.2: try- 執行成功回調，並將value值傳入，獲得x
4.3：執行resolvePromise函數，而且將promise2 , x ,resolve ,reject 做爲參數傳入
4.4：catch- reject(e)
5:判斷狀態是否爲rejected
5.1：等同於4.1
5.2：等同於4.2- 執行失敗回調，並將reason值傳入
5.3：等同於4.3
5.4：等同於4.4
6：判斷狀態是否爲PENDING時， 有兩種狀態
6.1：爲onFulfilled，執行self.onFulfilled.push()
6.2: 4.1---- 4.4  執行的是成功的回調
6.3:爲onRejected , 執行self.onRejected.push()
6.4: 4.1----4.4  執行的是失敗的回調
複製代碼

三： resolvePromise 函數

1: 定義resolvePromise函數， 接收四個參數promise2 , x , resolve ， reject 
2：判斷promise2 是否等於 x  ，條件真拋出錯誤 rejected(new TypeErr)
3: 判斷 x 是否爲真 or x=object   or x=function
4: 條件真 執行5  條件假： 直接resolve(x)
5: 定義一個lock ：userd , 進行嘗試執行try ,catch(e)
6： 此時x 爲一個obj or fn , 獲得 then , x.then
7: 對then 進行判斷是否爲函數， 是函數執行8 ， 不是函數 直接resovle(x)
8：條件真執行 then.call(x, ((y)=>{}) ,((z)=>{})
9: x爲this , y ：開鎖，而且將resolvePromise()函數進行再次執行, z:開鎖， 直接reject(z)
複製代碼

/*
 *1 new Promise 時 ， 須要傳遞一個excutor 執行器 ， 執行器馬上執行
 *2 excutor 接受二個參數 ， 分別是resolve 和 reject 
 *3 Promise 只能從pending 到 rejected 或者從 pending 到 fulfilled
 *4 Promise 到狀態一旦確認 ， 就不會再改變
 *5 Promise 都有then 方法， then方法接受倆個參數， 分別是Promise 成功的回調onfufilled , 和Promise 失敗的回調 onReject
 *6 若是調用then 時， Promise 已經成功 。 則執行onfulfilled , 並將promise的值做爲參數傳遞出去
 *  若是已經失敗 ， 那麼執行 onRejected  並將Promise 失敗的緣由做爲參數傳遞進去
 *  若是狀態是pending 須要將 onfulfilled 和onRejected 函數存放起來，等待狀態肯定後，再依次將對應的函數執行(發佈訂閱)
 *
 * then 的參數onFulfilled 和 onRejected 能夠缺省
 * Promise 能夠then 屢次， Promise 方法返回一個Promise
 * 
 */


//  定義狀態
const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';
function Promise(executor) {
    let self = this;
    self.status = PENDING;
    self.onFulfilled = [];//成功的回調
    self.onRejected = []; //失敗的回調
    //PromiseA+ 2.1
    function resolve(value) {
        if (self.status === PENDING) {
            self.status = FULFILLED;
            self.value = value;
            self.onFulfilled.forEach(fn => fn());//PromiseA+ 2.2.6.1
        }
    }

    function reject(reason) {
        if (self.status === PENDING) {
            self.status = REJECTED;
            self.reason = reason;
            self.onRejected.forEach(fn => fn());//PromiseA+ 2.2.6.2
        }
    }

    try {
        executor(rzesolve, reject);
    } catch (e) {
        reject(e);
    }
}

Promise.prototype.then = function (onFulfilled, onRejected) {
    //PromiseA+ 2.2.1 / PromiseA+ 2.2.5 / PromiseA+ 2.2.7.3 / PromiseA+ 2.2.7.4
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };
    let self = this;
    //PromiseA+ 2.2.7
    let promise2 = new Promise((resolve, reject) => {
        if (self.status === FULFILLED) {
            //PromiseA+ 2.2.2
            //PromiseA+ 2.2.4 --- setTimeout
            setTimeout(() => {
                try {
                    //PromiseA+ 2.2.7.1
                    let x = onFulfilled(self.value);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (e) {
                    //PromiseA+ 2.2.7.2
                    reject(e);
                }
            });
        } else if (self.status === REJECTED) {
            //PromiseA+ 2.2.3
            setTimeout(() => {
                try {
                    let x = onRejected(self.reason);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (e) {
                    reject(e);
                }
            });
        } else if (self.status === PENDING) {
            self.onFulfilled.push(() => {
                setTimeout(() => {
                    try {
                        let x = onFulfilled(self.value);
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (e) {
                        reject(e);
                    }
                });
            });
            self.onRejected.push(() => {
                setTimeout(() => {
                    try {
                        let x = onRejected(self.reason);
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (e) {
                        reject(e);
                    }
                });
            });
        }
    });
    return promise2;
}

function resolvePromise(promise2, x, resolve, reject) {
    //PromiseA+ 2.3.1
    if (promise2 === x) {
        reject(new TypeError('Chaining cycle'));
    }
    if (x && typeof x === 'object' || typeof x === 'function') {
        let used; //PromiseA+2.3.3.3.3 只能調用一次
        try {
            let then = x.then;
            if (typeof then === 'function') {
                //PromiseA+2.3.3
                then.call(x, (y) => {
                    //PromiseA+2.3.3.1
                    if (used) return;
                    used = true;
                    resolvePromise(promise2, y, resolve, reject);
                }, (r) => {
                    //PromiseA+2.3.3.2
                    if (used) return;
                    used = true;
                    reject(r);
                });

            }else{
                //PromiseA+2.3.3.4
                if (used) return;
                used = true;
                resolve(x);
            }
        } catch (e) {
            //PromiseA+ 2.3.3.2
            if (used) return;
            used = true;
            reject(e);
        }
    } else {
        //PromiseA+ 2.3.3.4
        resolve(x);
    }
}

 


Promise.defer = Promise.deferred = function () {
    let dfd = {};
    dfd.promise = new Promise((resolve, reject) => {
        dfd.resolve = resolve;
        dfd.reject = reject;
    });
    return dfd;
}









module.exports = Promise
複製代碼