function Promise(fn) {
    var state = 'pending',
        //這個(gè)value記錄的是promise本身值 即用于它.then(onFulfilled)的參數(shù)值
        value = null,
        //記錄它對(duì)應(yīng)的異步回調(diào)對(duì)象，當(dāng)resolve執(zhí)行的時(shí)候，會(huì)異步執(zhí)行這些函數(shù)
        deferreds = [];

    //then會(huì)將一下符合條件的回調(diào)加入 deferred    
    

    //須知
    /*  new Promise_A_(resolve => resolve()).then(onFulfilled_B_)_C_ 

    最麻煩的是 onFulfilled 返回也返回一個(gè) promise對(duì)象 下面討論這種情況

    * 假設(shè)第一個(gè) new Promise 為 Promise A
    * onFulfilled 返回的promise 為 Promise B
    * then 本身返回的Promise 為 Promise C
    * 必須是 A 狀態(tài)確定即執(zhí)行resolve  然后在 B 狀態(tài)確定  然后再是 C狀態(tài)確定
    * 那么如何才能確保上面的流程執(zhí)行？
    * 由于執(zhí)行resolve狀態(tài)才能確定， 那么上面執(zhí)行情況一定是
    * A 中的 resolve 中 調(diào)用 B 的 resolve  B的resolve中 調(diào)用C的resolve
    * 參數(shù)如何傳遞？ 利用好promise 里面的value就行，而且每個(gè)then里面的onfulfilled函數(shù)的返回值都作
    */


    this.then = function (onFulfilled, onRejected) {

        //每個(gè)then自動(dòng)返回一個(gè)promise,
        return new Promise(function (resolve, reject) {

        //這里可以獲取 這個(gè)then創(chuàng)建的promise的resolve函數(shù) 因?yàn)樗锩鏁?huì)調(diào)用fn(resolve)
        //獲取這個(gè)resolve函數(shù)可以做流程控制 控制這個(gè)resolve什么時(shí)候執(zhí)行 也就是promise C 
        //什么時(shí)候狀態(tài)確定
        //promiseC 什么時(shí)候狀態(tài)確定呢？它必須在 onFulfilled 返回的promiseB狀態(tài)確定后才能確定
        //由于PromiseB 在PromiseA的 resolve函數(shù)里面執(zhí)行 所以我們暫時(shí)把 onFulfilled 和 這個(gè)resolve
        //保存起來(lái)
        //promise中的fn是 立即執(zhí)行的 不用擔(dān)心handle獲取不到數(shù)據(jù)
            handle({
                onFulfilled: onFulfilled || null,
                onRejected: onRejected || null,
                resolve: resolve,
                reject: reject
            });
        });
    };


    //這個(gè)handler是非常重要的，異步里面當(dāng)前promise狀態(tài)確定了以后也直接調(diào)用它
    //之前說(shuō)了 promsieA 狀態(tài)確定 才執(zhí)行promiseB的then C也同理
    function handle(deferred) {

        //當(dāng)當(dāng)前的promise對(duì)象為pendding時(shí)候 直接加入到異步回調(diào)中
        if (state === 'pending') {
            deferreds.push(deferred);
            return;
        }

        //當(dāng)前promise狀態(tài)已經(jīng)確定了話 就直接執(zhí)行then參數(shù)函數(shù)，當(dāng)然如果存在話
        var cb = state === 'fulfilled' ? deferred.onFulfilled : deferred.onRejected,
            ret;
        //這里是非常巧妙的 如果then參數(shù)不處理的話，自動(dòng)交給then返回的promise對(duì)象處理
        //起到冒泡的作用
        if (cb === null) {
            cb = state === 'fulfilled' ? deferred.resolve : deferred.reject;
            //如果then參數(shù)不出來(lái) 那么之前把promiseA的value復(fù)制給promiseC的resolve
            cb(value);
            return;
        }
        
        //如果then的參數(shù)處理了 比如onFulfilled
        //那么把onFuillfilled的返回值 當(dāng)成value傳遞給promiseC
        //這個(gè)返回值 分為兩種情況 一種為 promsie 一種為 普通值
        //如果為promise的話 那么必須等待這個(gè)promiseB狀態(tài)確定后 promiseC才執(zhí)行它的resolve
        ret = cb(value);
        deferred.resolve(ret);
    }

    function resolve(newValue) {
        if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
            var then = newValue.then;

            //如果 onFulfilled 返回值為promise對(duì)象時(shí)
            if (typeof then === 'function') {
                //那么 先執(zhí)行promiseB的then  然后把它的value 傳遞給promiseC的resolve 或者reject
                //即實(shí)現(xiàn)了 promsieB-->到promiseC的控制
                then.call(newValue, resolve, reject);
                return;
            }
        }

        //如果不是promise對(duì)象的話, 直接調(diào)用異步回調(diào) 而且設(shè)置promise對(duì)象的value
        state = 'fulfilled';
        value = newValue;
        finale();
    }

    function reject(reason) {
        state = 'rejected';
        value = reason;
        finale();
    }

    function finale() {

        // resolve后執(zhí)行的回調(diào) 必須異步的
        setTimeout(function () {
            deferreds.forEach(function (deferred) {
                handle(deferred);
            });
        }, 0);
    }

    fn(resolve, reject);
}