手写 Promise篇

class Promise {
  constructor(executor) {
    (this.promiseResult = null), (this.promiseState = "pending");
    this.callback = [];
    let self = this;
    // 定义 resolve 函数
    function resolve(data) {
      // 判断 只返回一个结果
      if (self.promiseState !== "pending") return;
      (self.promiseState = "resolved"), (self.promiseResult = data);

      // 执行回调函数
      setTimeout(()=>{
        self.callback.forEach((item) => {
            item.onResolve(data);
          });
      })
    }
    // 定义 reject 函数
    function reject(data) {
      if (self.promiseState !== "pending") return;
      (self.promiseResult = data), (self.promiseState = "rejected");
        setTimeout(()=>{
            self.callback.forEach((item) => {
                item.onReject(data);
              });
        })
      
    }
    try {
      executor(resolve, reject);
    } catch (e) {
      reject(e);
    }
  }
  // 定义 then 方法
  then(onResolve, onReject) {
    let self = this;
    if (typeof onReject !== "function") {
      onReject = (row) => {
        throw row;
      };
    }
    if (typeof onResolve !== "function") {
      onResolve = (value) => value;
    }
    return new Promise((resolve, reject) => {
      function callback(type) {
        try {
          let result = type(self.promiseResult);
          if (result instanceof Promise) {
            result.then(
              (v) => {
                resolve(v);
              },
              (r) => {
                reject(r);
              }
            );
          } else {
            resolve(result);
          }
        } catch (error) {
          reject(error);
        }
      }
      if (this.promiseState === "resolved") {
          setTimeout(()=>{
            callback(onResolve);
          })
      }
      if (this.promiseState === "rejected") {
          setTimeout(()=>{
            callback(onReject);
          })
      }
      if (this.promiseState === "pending") {
        // 保存 回调函数
        this.callback.push({
          onResolve: function () {
            callback(onResolve);
          },
          onReject: function () {
            callback(onReject);
          },
        });
      }
    });
  }
  // 定义 catch 方法
  catch(onReject) {
    return this.then(undefined, onReject);
  }
  // 定义 resolve 方法
  static resolve(value) {
    return new Promise((resolve, reject) => {
      if (value instanceof Promise) {
        value.then(
          (v) => {
            resolve(v);
          },
          (r) => {
            reject(r);
          }
        );
      } else {
        resolve(value);
      }
    });
  }
  // 定义 reject 方法
  static reject(value) {
    return new Promise((resolve, reject) => {
      reject(value);
    });
  }
  // 定义 all 方法
  static all(promises) {
    return new Promise((resolve, reject) => {
      let count = 0;
      let arr = [];
      for (let i = 0; i < promises.length; i++) {
        count++;
        promises[i].then(
          (v) => {
            arr[i] = v;
            if (count === promises.length) {
              resolve(arr);
            }
          },
          (r) => {
            reject(r);
          }
        );
      }
    });
  }
  // 定义 race 方法
  static race(promises) {
    return new Promise((resolve, reject) => {
      for (let i = 0; i < Promise.length; i++) {
        promises[i].then(
          (v) => {
            resolve(v);
          },
          (r) => {
            reject(r);
          }
        );
      }
    });
  }
}