Promise简易实现

仅供自己学习记录

const PENDING = Symbol.for('pending');
const FULFILLED = Symbol.for('fulfilled');
const REJECTED = Symbol.for('rejected');

class MyPromise {
  constructor(func) {
    this.state = PENDING;
    this.value;
    this.sucCallbacks = [];
    this.errCallbacks = [];
    try {
      func(this.resolve.bind(this), this.reject.bind(this));
    } catch (e) {
      this.reject(e);
    }
  }
  resolve(value) {
    if (this.state !== PENDING) return;
    this.state = FULFILLED;
    // 这里异步执行回调，保证后续then能添加完回调
    // 实际代码中这里应该是开一个微任务，现暂时用宏任务代替
    setTimeout(() => {
      this.sucCallbacks.forEach(callback => {
        callback(value);
      });
    }, 0);
  }
  reject(error) {
    if (this.state !== PENDING) return;
    this.state = REJECTED;
    setTimeout(() => {
      this.errCallbacks.forEach(callback => {
        callback(error);
      });
    }, 0);
  }
  then(sucCallback, errCallback) {
    const { state, value } = this;
    return new MyPromise((resolve, reject) => {
      // 保证一下回调函数，用于处理回调函数中的return
      const sucEnhancer = val => {
        if (typeof sucCallback !== 'function') {
          resolve(val);
        } else {
          const result = sucCallback(val);
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            resolve(result);
          }
        }
      };
      const errEnhancer = err => {
        if (typeof errCallback !== 'function') {
          reject(err);
        } else {
          const result = errCallback(err);
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            reject(result);
          }
        }
      };
      if (state === PENDING) {
        this.sucCallbacks.push(sucEnhancer);
        this.errCallbacks.push(errEnhancer);
      }
      // 如果state已经改变，则直接执行回调
      if (state === FULFILLED) {
        sucEnhancer(value);
      }
      if (state === REJECTED) {
        errEnhancer(value);
      }
    });
  }
  catch(errCallback) {
    return this.then(undefined, errCallback);
  }
  finally(callback) {
    return this.then(callback, callback);
  }
  /**
   * 1、对value为MyPromise，直接返回；
   * 2、对value为thenable对象，通过MyPromise包装一层返回；
   * 3、对value为其它情况时，包装一层MyPromise，并直接resolve(value)
   */
  static resolve(value) {
    if (typeof value === 'undefined') {
      // 如果value未定义，则包装一层MyPromise返回
      return new MyPromise(resolve => {
        resolve();
      });
    }
    if (value instanceof MyPromise) {
      // 如果value已经是MyPromise，则直接返回
      return value;
    }
    if (typeof value === 'object' && typeof value.then === 'function') {
      // 如果是thenable对象，则包装一层
      return new MyPromise((resolve, reject) => {
        value.then(resolve, reject);
      });
    }
    return new MyPromise(resolve => {
      resolve(value);
    });
  }
  static reject(err) {
    return new MyPromise((resolve, reject) => {
      reject(err);
    });
  }
  // list全部完成后，无论成功失败，执行回调
  static allSettled(callbackList) {
    return new MyPromise((resolve, reject) => {
      const result = [];
      let count = callbackList.length;
      if (!count) {
        resolve(result);
        return;
      }
      const isEnd = (val, i) => {
        result[i] = val;
        if (!--count) {
          resolve(results)
        }
      };
      callbackList.forEach((callback, i) => {
        MyPromise.resolve(callback()).then(
          value => {
            isEnd(value, i);
          },
          err => {
            isEnd(err, i);
          }
        );
      });
    });
  }
  static all(callbackList) {
    return new MyPromise((resolve, reject) => {
      let count = callbackList.length;
      let result = [];
      if (!count) {
        resolve(result);
        return;
      }
      callbackList.forEach((callback, i) => {
        MyPromise.resolve(callback()).then(val => {
          result[i] = val;
          // 所有请求完成时，resolve该Promise
          if (!--count) {
            resolve(result);
          }
        }, err => {
          // 有一个请求错误直接reject
          reject(err);
        });
      });
    });
  }
  static race(callbackList) {
    return new MyPromise((resolve, reject) => {
      let count = callbackList.length;
      let result = [];
      if (!count) {
        resolve(result);
        return;
      }
      callbackList.forEach((callback, i) => {
        MyPromise.resolve(callback()).then(val => {
          resolve(val);
        }, err => {
          // 有一个请求错误直接reject
          reject(err);
        });
      });
    })
  }
}