手写系列之--promise

// class
const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected'

class MyPromise{
  constrctor(executor){
    this._status = PENDING；
    this._value = null;
    this.fullfilledFuncs = [];
    this.rejectedFuncs = [];
    
    const _resolve = (val)=>{
      const run = ()=>{
        if(this._status === PENDING) return ;
        this._status = FULFILLED ;
        this._value = val;
        while(this.fullfilledFuncs.length >0){
          const cb = fullfilledFuncs.shift();
          cb(val);
        }
      }
      setTimeout(run)
    };
    const _rejected = (val)=>{
      const run = ()=>{
        if(this._status === PENDING) return ;
        this._status = REJECTED;
        this._value = val;
        while(this.fullfilledFuncs.length >0){
          const cb = rejectedFuncs.shift();
          cb(val);
        }
      }
      setTimeout(run)
    };
    executor(_resolve, _rejected);
   }
   then(resolveFn,rejectedFn){
     typeof resolveFn !== 'function' ? resolveFn = res=>res : null;
     typeof rejectedFn !== 'function' ? rejectedFn = ()=> new Error() : null;
     return new myPromise((resolve,reject)=>{
       const fulfilledFunc = value => {
         try {
           let x = resolveFn(value)
           x instanceof MyPromise ? x.then(resolve, rejected) : resolve(x)
         } catch (error) {
           reject(error)
         }
       }
       const rejectedFunc  = error => {
         try {
           let x = rejectFn(error)
           x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
         } catch (error) {
           reject(error)
         }
       }
       if(this._status === PENDING){
         this.fullfilledFuncs.push(fulfilledFunc);
         this.rejectedFuncs.push(rejectedFunc)
       }else if(this._status === FULFILLED){
         fulfilledFunc(this._value)
       } else if(this._status === REJECTED ){
         rejectedFunc(this._value)
       }
     })

   };
   catch(rejectedFn) {
    return this.then(undefined, rejectedFn)
   }
   finally(callback) {
     return this.then(
       value => MyPromise.resolve(callback()).then(() => value),   
       reason => MyPromise.resolve(callback()).then(() => { throw reason }) 
     )
   }
   static resolve(value) {
     if(value instanceof MyPromise) return value 
     return new MyPromise(resolve => resolve(value))
   }
   static reject(reason) {
     return new MyPromise((resolve, reject) => reject(reason))
   }
   static all(promiseArr) {
    let index = 0
    let result = []
    return new MyPromise((resolve, reject) => {
      promiseArr.forEach((p, i) => {
        MyPromise.resolve(p).then(
          val => {
            index++
            result[i] = val
            if(index === promiseArr.length) {
              resolve(result)
            }
          },
          err => {
            reject(err)
          }
        )
      })
    })
  }
  static race(promiseArr) {
    return new MyPromise((resolve, reject) => {
      for (let p of promiseArr) {
        MyPromise.resolve(p).then(  
          value => {
            resolve(value)     
          },
          err => {
            reject(err)
          }
        )
      }
    })
  }
}