Promise 实现 then的链式调用

const resolvePromise = (promise2, result, resolve, reject) => {
  let consumed = false;
  let thenable;
  // 判断 result是否是Promise实例 
  if (result instanceof Promise) {
    if (result.status == "pending") {
      return result.then(function (data) {
        resolvePromise(promise2, data, resolve, reject);
      }, reject);
    } else {
      result.then(resolve, reject);
    }
    return;
  }
  // 判断result 是否是函数或者对象
  let isComplexResult = (target) =>
    (typeof target === "function" || typeof target === "object") &&
    target !== null;
   // 判断返回的是疑似Promise类型
  if (isComplexResult(result)) {
    try {
      thenable = result.then;
      // 判断返回值是否是promise类型
      if (typeof thenable === "function") {
        thenable.call(
          result,
          function (data) {
            if (consumed) return;
            consumed = true;
            return resolvePromise(promise2, data, resolve, reject);
          },
          function (error) {
            if (consumed) return;
            consumed = true;
            return reject(error);
          }
        );
      } else {
      // 普通值
        resolve(result);
      }
    } catch (e) {
      if (consumed) return;
      consumed = true;
      return reject(e);
    }
  } else {
   // 普通值
    resolve(result);
  }
};
Promise.prototype.then = function (onFulfilled, onRejected) {
  onFulfilled =
    typeof onFulfilled == "function" ? onFulfilled : (value) => value;
  onRejected =
    typeof onRejected == "function"
      ? onRejected
      : (reason) => {
          throw reason;
        };
  let self = this;
  let promise2;
  // promise状态是fulfilled
  if (self.status == "fulfilled") {
    return (promise2 = new Promise((resolve, reject) => {
      setTimeout(function () {
        try {
          let result = onFulfilled(self.value);
          resolvePromise(promise2, result, resolve, reject);
        } catch (e) {
          reject(e);
        }
      });
    }));
  }
  //promise状态是rejected
  if (self.status == "rejected") {
    return (promise2 = new Promise((resolve, reject) => {
      setTimeout(function () {
        try {
          let result = onRejected(self.value);
          resolvePromise(promise2, result, resolve, reject);
        } catch (e) {
          reject(e);
        }
      });
    }));
  }
  //promise状态是pending
  if (self.status == "pending") {
   // 链式调用 返回一个Promise实例
    return (promise2 = new Promise((resolve, reject) => {
    
      self.OnFunctionArrayFuill.push(() => {
        try {
          // 新的promise的resolve的值是onFulfilled处理后的值
          let result = onFulfilled(self.value);
          resolvePromise(promise2, result, resolve, reject);
        } catch (e) {
          reject(e);
        }
      });

      self.OnFunctionArrayError.push(() => {
        try {
        // 新的promise的onRejected的值是onFulfilled处理后的值
          let result = onRejected(self.reason);
          // 处理result是普通的值或者Promise实例
          resolvePromise(promise2, result, resolve, reject);
        } catch (e) {
          reject(e);
        }
      });
    }));
  }
};