从零实现Promise完全体

class MyPromise {
  // 构造函数接受一个执行器函数，该函数会立即执行
  constructor(executor) {
    // 初始化状态为 'pending'
    this.state = 'pending';
    this.value = undefined; // 存储成功的值
    this.reason = undefined; // 存储失败的原因
    this.onResolvedCallbacks = []; // 存储成功时的回调
    this.onRejectedCallbacks = []; // 存储失败时的回调

    // 成功的处理函数
    const resolve = (value) => {
      if (this.state === 'pending') {
        this.state = 'fulfilled'; // 状态变为已完成
        this.value = value; // 保存值
        // 执行所有成功的回调
        this.onResolvedCallbacks.forEach(callback => callback(value));
      }
    };

    // 失败的处理函数
    const reject = (reason) => {
      if (this.state === 'pending') {
        this.state = 'rejected'; // 状态变为已拒绝
        this.reason = reason; // 保存失败的原因
        // 执行所有失败的回调
        this.onRejectedCallbacks.forEach(callback => callback(reason));
      }
    };

    try {
      // 执行传入的执行器函数
      executor(resolve, reject);
    } catch (error) {
      reject(error); // 如果执行器抛出异常，直接调用 reject
    }
  }

  // then方法，链式调用的基础
  then(onFulfilled, onRejected) {
    // 如果 onFulfilled 或 onRejected 没有传入，给它们默认值（防止不传时出错）
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };

    // 返回一个新的 MyPromise 实现链式调用
    return new MyPromise((resolve, reject) => {
      // 处理成功回调
      const handleResolved = () => {
        try {
          // 执行成功回调并处理返回值
          const result = onFulfilled(this.value);
          // 如果返回值是一个 Promise，需要等待其 resolve
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            resolve(result); // 否则直接 resolve
          }
        } catch (error) {
          reject(error); // 如果执行回调出错，直接 reject
        }
      };

      // 处理失败回调
      const handleRejected = () => {
        try {
          const result = onRejected(this.reason);
          // 如果返回值是一个 Promise，需要等待其 resolve
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            reject(result); // 否则直接 reject
          }
        } catch (error) {
          reject(error); // 如果执行回调出错，直接 reject
        }
      };

      // 根据当前 Promise 的状态来决定调用哪个回调
      if (this.state === 'fulfilled') {
        setTimeout(handleResolved, 0); // 异步执行，防止同步调用时导致栈溢出
      } else if (this.state === 'rejected') {
        setTimeout(handleRejected, 0); // 异步执行，防止同步调用时导致栈溢出
      } else if (this.state === 'pending') {
        // 如果是 pending 状态，先将回调保存起来，等到状态改变时执行
        this.onResolvedCallbacks.push(handleResolved);
        this.onRejectedCallbacks.push(handleRejected);
      }
    });
  }

  // catch方法，简化版的错误处理
  catch(onRejected) {
    return this.then(null, onRejected);
  }

  // 静态方法：resolve，用于返回一个已经 resolved 状态的 Promise
  static resolve(value) {
    return new MyPromise((resolve) => resolve(value));
  }

  // 静态方法：reject，用于返回一个已经 rejected 状态的 Promise
  static reject(reason) {
    return new MyPromise((_, reject) => reject(reason));
  }

  // 静态方法：all，用于将多个 Promise 并行执行并返回一个新的 Promise
  static all(promises) {
    return new MyPromise((resolve, reject) => {
      const results = [];
      let completed = 0;

      // 遍历所有传入的 Promise
      promises.forEach((promise, index) => {
        // 如果是普通值，直接转换为 Promise
        MyPromise.resolve(promise).then((value) => {
          results[index] = value;
          completed += 1;
          // 当所有 Promise 都完成时，调用 resolve
          if (completed === promises.length) {
            resolve(results);
          }
        }).catch(reject); // 一旦有一个 Promise 失败，整个 Promise 就失败
      });
    });
  }

  // 静态方法：race，返回第一个完成的 Promise
  static race(promises) {
    return new MyPromise((resolve, reject) => {
      promises.forEach(promise => {
        MyPromise.resolve(promise).then(resolve).catch(reject);
      });
    });
  }
}