一、基础版
    手写方法时，根据功能来添加代码，不要死记代码

    1. let myPromise = new Promise((resolve, reject)=>{
    2.     setTimeout(()=>{resolve('resolved')},1000)
    3. });
    4. myPromise.then((res)=>{},(reason)=>{}).catch((error)=>{});
    6. function MPromise(excutor){
    7.   //创建的promise状态为pending
    8.     this.PromiseState = 'pending';
    9.   this.PromiseResult = null;
    11.   //判断resolve和reject接受参数是不是promise对象的方法
    12.   this.checkPromise = function(item){
    13.     //粗略判断是否有then方法
    14.       return typeof item === 'function'
    15.   }
    17.   //创建给excutor传入的resolve和reject方法
    18.   function resolve(param){
    19.     let isPromise = param && this.checkPromise(param);
    20.     //判断resolve处理的是否为promise，如果是的话，promise的状态由resolve处理的promise决定
    21.     if(!isPromise){
    22.       console.log('change PromiseState')
    23.       this.PromiseState = 'fullfilled'
    24.         this.PromiseResult = param
    25.     }else{
    26.         console.log('isPromise')
    27.       //如果是promise，等参数promise状态改变后调用起then方法，
    28.       //将resolve和reject方法传进入then回调函数,fullfilled时调用resolve，rejected时调用reject
    29.       param.then(resolve,this.reject)
    30.     }
    31.   }
    32.   function reject(param){
    33.       this.PromiseState = 'rejected'
    34.     this.PromiseResult = param
    35.   }
    38.   //(1)then方法，可以根据promise状选择性执行传入函数
    39.   //(2)根据参数函数执行结果返回值，创建新的promise并返回
    40.   //次函数有两个功能，为了解耦，将每个功能写为独立的函数
    41.    this.callBackHandler = function (handler){
    42.     let currentPromiseState = this.PromiseState,
    43.           promiseResult = this.PromiseResult,
    44.           handlerResult;
    45.     if(currentPromiseState === 'fullfilled'){
    46.       handlerResult = handler.onResolved(promiseResult)
    47.     }else if(currentPromiseState === 'rejected'){
    48.       handlerResult = handler.onrejected(promiseResult)
    49.     }
    50.     console.log('handlerResult', handlerResult)
    51.     return handlerResult
    52.   }
    54.   this.createNewPromise = function (handlerResult){
    55.     //先判断是否为promise，如果不是则创建一个新promise
    56.     let isPromise = this.checkPromise(handlerResult);
    57.     if(isPromise) return handlerResult
    58.     return new MPromise((resolve)=>{resolve(handlerResult)})
    59.   }
    61.   //this.then = function(cb1,cb2){
    62.   //  const currentPromiseState = this.PromiseState,
    63.   //        promiseResult = this.PromiseResult
    64.   //    if(currentPromiseState === 'fullfilled'){
    65.   //      cb1(promiseResult)
    66.   //  }else if(currentPromiseState === 'rejected'){
    67.   //      cb2(promiseResult)
    68.   //  }
    69.   //}
    71.   this.then = function(cb1,cb2){
    72.     //先执行回调函数，并保存返回值
    73.     let handler = {onResolved : cb1,onrejected : cb2},
    74.         promiseResult = this.callBackHandler(handler),
    75.         newPromise = this.createNewPromise(promiseResult);
    76.     return newPromise
    77.   }
    79.   this.catch = function(cb){
    80.     判断promiseState是否为rejected，才执行catch的回调函数
    81.     //先执行回调函数，并保存返回值
    82.     let handler = {onrejected : cb},
    83.         promiseResult = this.callBackHandler(handler),
    84.         newPromise = this.createNewPromise(promiseResult);
    85.     return newPromise
    86.   }
    89.   //给excutor函数提供两个函数方法参数，然后执行
    90.   excutor(resolve.bind(this),reject.bind(this))
    91. }
    93. let myPromise = new MPromise((resolve, reject)=>{
    94.     setTimeout(()=>{resolve('resolved')},1000)
    95. });
    96. myPromise
    97. .then((res)=>{console.log(res)},(reason)=>{console.log(reason)})
    98. .catch((error)=>{})