一步一步写出自己的Promise源码

 先贴出代码；

const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';
class AbsPromise {
    constructor() {
        this.value = '';
        this.status = PENDING;
        this.onresolvedQueue = [];
        this.onrejectedQueue = [];
        this._ID_ = Date.now()+Math.random();
    }
    then(){
        
    }
}

class Promise extends AbsPromise {
    constructor(handle) {
        super();
        handle(Promise._resolve(this), Promise._reject(this));
    }
    static _resolve(context) {
        return function (value) {
            // TODO value是一个promise,会等待value的状态
            if (context.status !== PENDING) {
                return;
            }
            context.status = FULFILLED;
            context.value = value;
            if (value instanceof Promise) {
                value.then(Promise._resolve(value), Promise._reject(value));
            }
            let job;
            while (job = context.onresolvedQueue.shift()) {
                job.call(context, value);
            }
        }
    }
    static _reject(context) {
        return function(){
            if (context.status !== PENDING) {
                return;
            }
            context.status = REJECTED;
            context.value = reason;
            let job;
            while (job = context.onresolvedQueue.shift()) {
                job.call(context, value);
            }
        }
    }
    then(onresolve, onreject){
        const that = this;
        return new Promise(function(resolve, reject){
             const resolveCb = that.resolveCb(onresolve, resolve, reject),
                   rejectCb = that.rejectCb(onresolve, resolve, reject),
                   cb = that.didThen(resolveCb, rejectCb);
                   cb();
        });
    }
    resolveCb(onresolve, resolve, reject){
        return (value) => {
            setTimeout(()=>{
                if(typeof onresolve != 'function') {
                    resolve(value);
                }
                const res = onresolve(value);
                if (res instanceof Promise) {
                    return res.then(resolve, reject);
                }
                resolve(res);
            });
        }
    }
    rejectCb(onreject, resolve, reject) {
        return (error) => {
            setTimeout(()=>{
                if(typeof onreject != 'function') {
                    resolve(error);
                }
                const res = onreject(error);
                if (res instanceof Promise) {
                    return res.then(resolve, reject);
                }
                resolve(res);
            });
        }
    }
    didThen(resolveed, rejected){
        const that = this, staus = that.status, value = that.value;
        return {
            [PENDING]: function(){
                that.onresolvedQueue.push(resolveed);
                that.onrejectedQueue.push(rejected);
            },
            [FULFILLED]: function(){
                resolveed(value);
            },
            [REJECTED]: function(){
                rejected(value);
            } 
        }[staus];
    }
}
var test = new Promise((resolve) => {
    console.log(1);
    setTimeout(()=>{console.log(3);resolve(4)});
});
var test2 = test.then((v)=>{console.log(v,5)});
var test3 = test.then((v)=>{console.log(v,6)});
console.log(2, test,test2,test3)
setTimeout(()=>{console.log(7,test,test2,test3)},100);

二 分析Promise构造函数和executor

待续