promise,手写piomise

// 假设有相应的 success、result、error 变量定义
const success: boolean = true;
const result: any = 'success result';
const error: any = 'error occurred';

new Promise<void>((resolve, reject) => {
  if (success) {
    resolve(result);
  } else {
    reject(error);
  }
}).then((result) => {
  // 处理成功回调
  console.log('Success:', result);
}).catch((err) => {
  // 处理失败回调
  console.error('Error:', err);
});

当手写一个 Promise 类时，需要实现 Promise 的三个状态（Pending、Fulfilled、Rejected）以及相关的方法（then、catch）。以下是一个简单的手写 Promise 的示例：

enum PromiseState {
  Pending = 'pending',
  Fulfilled = 'fulfilled',
  Rejected = 'rejected',
}

type Executor<T> = (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void;

class MyPromise<T> {
  private state: PromiseState = PromiseState.Pending;
  private value: T | undefined = undefined;
  private reason: any = undefined;
  private onFulfilledCallbacks: ((value: T) => void)[] = [];
  private onRejectedCallbacks: ((reason: any) => void)[] = [];

  constructor(executor: Executor<T>) {
    try {
      executor(this.resolve.bind(this), this.reject.bind(this));
    } catch (error) {
      this.reject(error);
    }
  }

  private resolve(value: T | PromiseLike<T>): void {
    if (this.state === PromiseState.Pending) {
      this.state = PromiseState.Fulfilled;
      this.value = value;
      this.onFulfilledCallbacks.forEach(callback => callback(value));
    }
  }

  private reject(reason: any): void {
    if (this.state === PromiseState.Pending) {
      this.state = PromiseState.Rejected;
      this.reason = reason;
      this.onRejectedCallbacks.forEach(callback => callback(reason));
    }
  }

  then<U>(onFulfilled: (value: T) => U, onRejected?: (reason: any) => U): MyPromise<U> {
    const newPromise = new MyPromise<U>((resolve, reject) => {
      if (this.state === PromiseState.Fulfilled) {
        try {
          const result = onFulfilled(this.value!);
          resolve(result);
        } catch (error) {
          reject(error);
        }
      } else if (this.state === PromiseState.Rejected && onRejected) {
        try {
          const result = onRejected(this.reason);
          resolve(result);
        } catch (error) {
          reject(error);
        }
      } else {
        this.onFulfilledCallbacks.push(value => {
          try {
            const result = onFulfilled(value);
            resolve(result);
          } catch (error) {
            reject(error);
          }
        });
        if (onRejected) {
          this.onRejectedCallbacks.push(reason => {
            try {
              const result = onRejected(reason);
              resolve(result);
            } catch (error) {
              reject(error);
            }
          });
        }
      }
    });
    return newPromise;
  }

  catch<U>(onRejected: (reason: any) => U): MyPromise<U> {
    return this.then(undefined, onRejected);
  }
}

// 示例用法
const promise = new MyPromise<string>((resolve, reject) => {
  setTimeout(() => {
    resolve('Promise resolved');
    // reject('Promise rejected');
  }, 1000);
});

promise.then(result => {
  console.log('Resolved:', result);
  return 'New Promise result';
}).then(newResult => {
  console.log('Chained Then:', newResult);
}).catch(error => {
  console.error('Rejected:', error);
});

这段代码实现了一个简单的 Promise 类 MyPromise，包括构造函数、resolve、reject、then 和 catch 方法。在构造函数中，接受一个执行器函数 executor，并在其中调用 resolve 和 reject 方法。在 then 方法中，根据 Promise 的状态调用相应的回调函数，并返回一个新的 Promise 对象。在 catch 方法中，简单地调用 then 方法并传入 undefined 作为成功回调函数。