手写promise

<script>
         const PENDING = 'pending'
         const RESOLVED = 'resolved'
         const REJECTED = 'rejected'
         function MyPromise(fn){
          //     保存初始化状态
          var self = this
          // 初始化状态
          this.state = PENDING
          // 用于保存resolve或者rejected传入的值
          this.value = null
          // 用于保存resolve的回调函数
          this.resolevedCallback=[]
          // 用于保存reject的回调函数
          this.rejectedCallback=[]
         
          // 状态转变为resolved方法
          function resolve(value){
               // 判断传入元素是否为Promise值，如果是，状态改变必须等待前一个状态后再进行改变
               if(vulue instanceof MyPromise){
                    return value.then(resolve,reject)
               }
               // 保证代码的执行顺序为本轮事件循环的末尾
               setTimeout(()=>{
                    // 只有状态为pending的时候才能转变
                    if(self.state ===PENDING){
                         // 修改状态
                         self.state =RESOLVED
                         // 设置传入的值
                         self.value = value
                         // 执行会调函数
                         self.resolevedCallback.forEach(callback=>{
                              callback(value)
                         })
                    }
               },0)
          }
          // 状态转变为rejected方法
          function reject(value){
               // 保证代码的执行顺序为本轮事件循环的末尾
               setTimeout(()=>{
                    // 只有状态为pending的时候才能转变
                    if(self.state ===PENDING){
                         // 修改状态
                         self.state =REJECTED
                         // 设置传入的值
                         self.value = value
                         // 执行会调函数
                         self.rejectedCallback.forEach(callback=>{
                              callback(value)
                         })
                    }
               },0)
          }

          // 将两个方法传入函数执行
          try{
               fn(resolve,reject)
          }catch(e){
               // 遇到错误，捕获，执行reject函数
               reject(e)
          }
         }
     MyPromise.prototype.then = function(onResolved,onRejected){
          // 首先判断两个参数是否为函数类型，因为这两个参数是可选参数
          onResolved = typeof onResolved==='function'? onResolved : value => value
          onRejected = typeof onRejected==='function'? onRejected : error => {throw error}
          // 如果是等待状态，将函数加入到对应列表
          if(this.state === PENDING){
               this.resolevedCallback.push(onResolved)
               this.rejectedCallback.push(onRejected)
          }
          // 如果状态已经凝固，就直接指向对应状态的函数
          if(this.state === RESOLVED){
               onResolved(this.value)
          }
          if(this.state === REJECTED){
               onRejected(this.value)
          }

     }
    </script>