实现一个简单的符合Promise/A+规范的Promise

简要介绍：Promise允许我们通过链式调用的方式来解决“回调地狱”的问题，特别是在异步过程中，通过Promise可以保证代码的整洁性和可读性。

一、Promise的使用

        var foo = new Promise(function (resolve, reject) {
            setTimeout(function () {
                resolve("success")
            }, 1000);
            console.log("创建一个promise");
        })
        foo.then((res) => {
            console.log(res)
        }).catch((err) => {
            console.log(err);
        })

//输出：
创建一个promise
success

上述是一个promise的实例，输出内容为，“创建一个promise”，延迟1000ms后，输出"success"。

从上述的例子可以看出，promise方便处理异步操作。此外promise还可以链式的调用。

二、Promise/A+规范

（1）一个promise必须有3个状态，pending，fulfilled(resolved)，rejected。

当处于pending状态的时候，可以转移到fulfilled(resolved)或者rejected状态。当处于fulfilled(resolved)状态或者rejected状态的时候，不可改变。

（2）一个promise必须有一个then方法，then方法接受两个参数： promise.then(onFulfilled,onRejected)

onFulfilled方法表示状态从pending——>fulfilled(resolved)时所执行的方法

onRejected表示状态从pending——>rejected所执行的方法。

三、实现符合Promise/A+规范的Promise

function myPromise(constructor){
    let that=this;
    that.status="pending" //定义状态改变前的初始状态
    that.value=undefined;//定义状态为resolved的时候的状态
    that.reason=undefined;//定义状态为rejected的时候的状态
    function resolve(value){
       if(that.status==="pending"){
          that.value=value;
          that.status="resolved";
       }
    }
    function reject(reason){
        //两个==="pending"，保证了状态的改变是不可逆的
       if(that.status==="pending"){
          that.reason=reason;
          that.status="rejected";
       }
    }
    //捕获构造异常
    try{
       constructor(resolve,reject);
    }catch(e){
       reject(e);
    }
}

myPromise.prototype.then=function(onFullfilled,onRejected){
   let that=this;
   switch(that.status){
      case "resolved":
        onFullfilled(that.value);
        break;
      case "rejected":
        onRejected(that.reason);
        break;
      default:       
   }
}