Promise理解的关键点：

1.内部有个状态标识，且只能被决议一次(完成或拒绝)

2.内部有个队列机制，将回调函数进行缓存，当状态改变后(由pending变成resolved或rejected)，执行相应的函数。

3.必须有个then方法，且只接受两个函数参数onFulfilled，onRejected。

大致流程为：
a.实例化空promise对象用来返回（保持then链式调用）
b.构造then(..)注册回调处理函数结构体
c.判断当前promise状态，pending状态存储延迟处理对象deffered。非pending状态执行resolved和rejected回调

4.链式调用，每次对Promise调用then(..)都会创建并返回一个新的Promise，我们可以将其链接起来

为什么必须是新的promise？假如then函数执行返回this调用对象本身，那么promise2的状态应该等于promise1同为resolved
因为状态是保存在 构造函数中的 所以必须是新的一个实力对象才可以
还需要依次调用 then 注册的回调处理函数

简单实现Promise 有不完善的地方 仅仅用做参考

/**
 * 手写 Promise 简易版 
 * node index.js 执行
 */
const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';

function Promise(fn){

    if(!(this instanceof Promise)) return new Promise(fn);

    var promise = this;
    promise._resolves = [];
    promise._rejects = [];
    promise._status = PENDING;  // 每个promise必须有且只有一个状态 只能从pending -> fulfilled 或者 pending -> rejected
    promise._data = null;
    function resolve(value){
        // * 假如传入的是不包含异步操作的函数，resolve就会先于 then 执行，也就是说 promise._resolves 是一个空数组。
        process.nextTick(function(){
            promise._status = FULFILLED;
            promise._data = value;
            promise._resolves.forEach(function(callback){
                callback(value)
            })
        })
    }

    function reject(reason){
        process.nextTick(function(){
            promise._status = REJECTED;
            promise._data = reason;
            promise._rejects.forEach(function(callback){
                callback(reason);
            })
        })
    }

    try{
        fn(resolve, reject);
    } catch(e){
        reject(e);
    }
}

// 重点
Promise.prototype.then = function(onFulfilled, onRejected){
    var promise = this;
    onFulfilled = typeof onFulfilled === 'function' 
                ? onFulfilled 
                : function (value) {return value};

    // * 这里注意 必须throw出去 不然下一个then 仍然会接收到 值
    onRejected = typeof onRejected === 'function' 
                ? onRejected 
                : function (reason) {throw reason}; 
    // // * 链式调用 为什么不能返回this 而必须要新建一个promise 因为每个promise的状态是唯一的 一旦变更 不可再修改
    return new Promise(function(resolve, reject){
        function handle(value){
            var ret = onFulfilled(value);
            // * 这里需要注意 为了then里面的函数能够对promise对象进行处理
            if(ret && typeof ret['then'] == 'function'){
                // 如果是promise对象， 则调用then方法 形成一个嵌套，直到不是promise对象为止
                ret.then(resolve, reject);
            }else{
                resolve(ret);
            }
        }

        function errback(reason){
            var reason = onRejected(reason);
            if(reason && typeof reason['then'] == 'function'){
                // 如果是promise对象， 则调用then方法 形成一个嵌套，直到不是promise对象为止
                ret.then(resolve, reject);
            }else{
                resolve(reason);
            }
        }
        // * 需要注意的是 这里的promise 指向的是上一个promise对象 ，而不是刚刚新建的这个promise对象
        if(promise._status == PENDING){
            promise._resolves.push(handle);
            promise._rejects.push(errback);
        }else if(promise._status == FULFILLED){
            handle(promise._data);
        }else{
            errback(promise._data);
        }
    })
}