Promise的实现

function resolvePromise(promise, result, resolve, reject) {
  if (promise === result) {
    return reject(new TypeError('Chaining cycle detected for promise'));
  }

  if (result instanceof MyPromise) {
    result.then(resolve, reject);
  } else {
    resolve(result);
  }
}

class MyPromise{
  constructor(executor){
    this.status = "pending";
    this.resolveList = [];
    this.rejectList = [];
    
    const resolve = (args)=>{
        if(this.status === "pending"){
           this.status = "fulfilled";
           this.resolveList.forEach((callback) => callback(args));
        }
        
    }

    const reject = (args) => {
        if(this.status === "pending"){
          this.status = "rejected";
          this.rejectList.forEach((callback) => callback(args));
        }
    }

    try {
      executor(resolve, reject);
    } catch (error) {
      reject(error);
    }
  }
  
  then(resolveCallback, rejectCallback){
    resolveCallback = typeof resolveCallback === 'function' ? resolveCallback : (value) => value;
    rejectCallback = typeof rejectCallback === 'function' ? rejectCallback : (reason) => { throw reason; };

    const promise = new MyPromise((resolve, reject) => {
      if (this.status === 'fulfilled') {
        setTimeout(() => {
          try {
            const result = resolveCallback();
            resolvePromise(promise, result, resolve, reject);
          } catch (error) {
            reject(error);
          }
        }, 0);
      }

      if (this.status === 'rejected') {
        setTimeout(() => {
          try {
            const result = rejectCallback();
            resolvePromise(promise, result, resolve, reject);
          } catch (error) {
            reject(error);
          }
        }, 0);
      }

      if (this.status === 'pending') {
        this.resolveList.push(() => {
          setTimeout(() => {
            try {
              const result = resolveCallback();
              resolvePromise(promise, result, resolve, reject);
            } catch (error) {
              reject(error);
            }
          }, 0);
        });

        this.rejectList.push(() => {
          setTimeout(() => {
            try {
              const result = rejectCallback();
              resolvePromise(promise, result, resolve, reject);
            } catch (error) {
              reject(error);
            }
          }, 0);
        });
      }
    });

    return promise;
  }

  catch(onRejected) {
    return this.then(null, onRejected);
  }

  // all promiseList列表中有一个失败 结果就为reject
  all(promiseList){
    const result = [];
    return new MyPromise((resolve,reject)=>{
      promiseList.map((item,i)=>{
        // MyPromise.resolve()用于处理传入值不为Promise的情况
        MyPromise.resolve(item).then((res)=>{
           result[i] = res;
           if(result.length === promiseList.length){
              resolve(result)
           }
        },(err)=>{
          reject(err)
        })
      })
    })
  }

  race(promiseList){
    return new MyPromise((resolve,reject)=>{
      promiseList.map((item,i)=>{
        // MyPromise.resolve()用于处理传入值不为Promise的情况
        MyPromise.resolve(item).then((res)=>{
          resolve(res)
        },(err)=>{
          reject(err)
        })
      })
    })
  }

 retry(fn, count){
     
    return new MyPromise((resolve, reject)=>{
        const fnTemp = function(){
            MyPromise.resolve(fn).then(res=>{
              resolve(res)  
            }, (err) =>{
              if(count === 0){
                  reject(err)
              }else{
                  count--;
                  fnTemp()
              }
              
          })
     }
    return fnTemp

    })

  }

}