一、Promise核心机制解析

1.1 三态模型与状态不可逆

Promise规范定义了三种状态：pending（初始）、fulfilled（成功）、rejected（失败）。状态转换具有单向性，一旦从pending转为fulfilled/rejected，将永久保持。这种设计避免了竞态条件，确保异步操作的确定性。

class MyPromise {
  constructor(executor) {
    this.state = 'pending'; // 初始状态
    this.value = undefined; // 成功值
    this.reason = undefined; // 失败原因
    this.onFulfilledCallbacks = []; // 成功回调队列
    this.onRejectedCallbacks = []; // 失败回调队列
  }
}

1.2 异步任务队列管理

当Promise状态变更时，需要将对应的回调函数推入微任务队列。由于原生环境无法直接操作微任务队列，我们通过setTimeout模拟异步执行，实际开发中可使用queueMicrotask或MutationObserver优化。

const resolve = (value) => {
  if (this.state === 'pending') {
    this.state = 'fulfilled';
    this.value = value;
    // 模拟微任务执行
    setTimeout(() => {
      this.onFulfilledCallbacks.forEach(fn => fn());
    }, 0);
  }
};

二、链式调用实现原理

2.1 then方法设计

then方法需返回新的Promise实例以实现链式调用。关键在于处理返回值：当回调返回普通值时，新Promise自动resolve；返回Promise时需等待其状态变更。

then(onFulfilled, onRejected) {
  const promise2 = new MyPromise((resolve, reject) => {
    const handleFulfilled = (value) => {
      try {
        if (typeof onFulfilled !== 'function') {
          resolve(value); // 穿透处理
        } else {
          const x = onFulfilled(value);
          resolvePromise(promise2, x, resolve, reject);
        }
      } catch (e) {
        reject(e);
      }
    };
    // 类似实现handleRejected...
  });
  return promise2;
}

2.2 resolvePromise规范实现

此函数处理then回调的返回值，需遵循Promise/A+规范中的值穿透和Promise链解析规则：

function resolvePromise(promise2, x, resolve, reject) {
  if (promise2 === x) {
    return reject(new TypeError('Chaining cycle detected'));
  }
  let called = false;
  if (x instanceof MyPromise) {
    x.then(
      y => resolvePromise(promise2, y, resolve, reject),
      reject
    );
  } else if (typeof x === 'object' || typeof x === 'function') {
    try {
      const then = x.then;
      if (typeof then === 'function') {
        then.call(
          x,
          y => {
            if (called) return;
            called = true;
            resolvePromise(promise2, y, resolve, reject);
          },
          reject
        );
      } else {
        resolve(x);
      }
    } catch (e) {
      if (called) return;
      called = true;
      reject(e);
    }
  } else {
    resolve(x);
  }
}

三、跨年场景实用增强

3.1 延迟执行装饰器

在跨年倒计时等场景中，可通过装饰器模式实现延迟执行：

function delayPromise(promise, timeout) {
  return new MyPromise((resolve, reject) => {
    const timer = setTimeout(() => {
      promise.then(resolve, reject);
    }, timeout);
    promise.then(() => clearTimeout(timer));
  });
}
// 使用示例
delayPromise(fetch('https://api.example.com/newyear'), 5000)
  .then(console.log);

3.2 并发控制工具

实现类似Promise.all的并发控制，适用于批量请求新年祝福接口：

static all(promises) {
  return new MyPromise((resolve, reject) => {
    const results = [];
    let count = 0;
    promises.forEach((promise, index) => {
      MyPromise.resolve(promise).then(
        value => {
          results[index] = value;
          if (++count === promises.length) resolve(results);
        },
        reject
      );
    });
  });
}

四、调试与优化技巧

4.1 状态追踪日志

在开发阶段添加状态变更日志，便于定位异步问题：

class DebugPromise extends MyPromise {
  constructor(executor) {
    super(executor);
    const originalResolve = this.resolve;
    this.resolve = (value) => {
      console.log(`[DEBUG] Promise resolved with:`, value);
      originalResolve.call(this, value);
    };
    // 类似实现reject的日志...
  }
}

4.2 性能优化方案

1. 回调合并：对于高频触发的Promise（如实时数据流），可采用节流合并回调
2. 错误边界：在链式调用顶端添加全局错误捕获
3. 内存管理：及时清理已完成的Promise回调引用

五、完整实现示例

class MyPromise {
  // 前文实现代码...
  static resolve(value) {
    if (value instanceof MyPromise) return value;
    return new MyPromise(resolve => resolve(value));
  }
  static reject(reason) {
    return new MyPromise((_, reject) => reject(reason));
  }
  catch(onRejected) {
    return this.then(null, onRejected);
  }
  finally(onFinally) {
    return this.then(
      value => MyPromise.resolve(onFinally()).then(() => value),
      reason => MyPromise.resolve(onFinally()).then(() => { throw reason; })
    );
  }
}
// 测试用例
new MyPromise((resolve) => {
  setTimeout(() => resolve('新年快乐'), 1000);
})
.then(console.log)
.catch(console.error);

六、学习建议与进阶方向

1. 规范对比：对照Promise/A+规范实现剩余测试用例
2. 源码解析：研究V8引擎中Promise的底层实现
3. 异步模式：结合Generator/Async函数理解Promise的进化路径
4. 工具开发：尝试实现Promise.race、Promise.any等API

通过系统性的手写实现，开发者不仅能深入理解异步编程原理，更能培养出解决复杂并发问题的能力。这种从底层到上层的认知构建，对于处理高并发场景（如跨年活动流量峰值）具有重要实践价值。