ES6 的某入门姿势

今天分享一下promise类的手动实现方法，具体代码如下，
注释部分是一些需要实现和注意的重点~

class Ypromise{
    //1. 1个立即执行函数
    constructor(executor){
        try{
            executor(this.resolve, this.reject);
        } catch(e){
            this.reject(e);
        }
    }
    // 2. promise对象的状态
    status = 'pending'
    //2. 两个需要层层传递的参数
    trans_value = undefined
    trans_error = undefined
    //3. 两个回调函数队列
    successQueue = []
    failedQueue = []
    //4. resolve, reject函数都要定义
    resolve = (value)=>{
        //5. resolve要做的有三件事儿
        //5-1. 改变promise对象的状态
        //5-2. 把value传递给下一个then函数，作为successCallBack的参数
        //5-3. 执行后面同步then方法注册到successQueue中的回调函数
        if(this.status === 'pending'){
            this.status = 'fullfilled';
        }   
        this.trans_value = value;
        while(this.successQueue.length){
            this.successQueue.shift()(this.trans_value);
        }
    }
    reject = (error)=>{
        if(this.status === 'pending'){
            this.status = 'failed';
        }   
        this.trans_error = error;
        while(this.failedQueue.length){
            this.failedQueue.shift()(this.trans_error);
        }
    }
    then(successCallBack, failCallBack){
        //6. then要做的事情是创建一个新的Promise对象然后返回，不能返回上面的Promise
        // 同步情况：判断状态，执行对应的CallBack
        // 异步情况：放入对应的回调队列中
        var Npromise = new Xpromise((resolve, reject)=>{
            if(this.status === 'fulfilled'){
                setTimeout(()=>{
                    try{
                        let x = successCallBack(this.trans_value);
                        this.resolvePromise(Npromise, x, resolve, reject);
                    } catch(e){
                        reject(e);
                    }    
                },0);
                
            } else if(this.status === 'failed'){
                setTimeout(()=>{
                    try{
                        let x = failCallBack(this.trans_error);
                        this.resolvePromise(Npromise, x, resolve, reject);
                    } catch(e){
                        reject(e.message);
                    }    
                },0);
                
            } else {
                successCallBack && this.successQueue.push(successCallBack);
                failCallBack && this.failedQueue.push(failCallBack);
            }
        });
        return Npromise;
        
    }
    resolvePromise(lastPromise, callBackResult, resolve, reject){
        if(callBackResult instanceof Xpromise){    
            if(lastPromise === callBackResult){
                reject('cycle error');
            } else {
                callBackResult.then(resolve, reject);
            }
        } else {
            resolve(callBackResult);
        }
        
    }
}
new Ypromise(function(resolve, reject){reject('error executor')})
.then(val=>console.log('1-then',val),err=>{console.log('1-error', err);throw Error('1-error');})
.then(val=>console.log('2-then', val), err=>console.log('2-error', err));