一、混沌初开：Promise的表象与困惑

初次接触Promise时，开发者往往被其优雅的链式调用所吸引：

fetch('/api/data')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));

这种看似简单的异步处理模式，背后却隐藏着复杂的机制。当我尝试手写一个简化版Promise时，第一个困惑便是：如何实现状态机管理？原生Promise有三种状态（pending/fulfilled/rejected），且状态一旦改变就不可逆。这个特性看似简单，但要在代码中精确控制却需要深思熟虑。

通过阅读ECMAScript规范和V8引擎源码，我发现关键在于使用闭包保存状态，并通过setter拦截实现状态变更的锁机制：

class MyPromise {
  constructor(executor) {
    this.state = 'pending';
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    const resolve = (value) => {
      if (this.state === 'pending') {
        this.state = 'fulfilled';
        this.value = value;
        this.onFulfilledCallbacks.forEach(fn => fn());
      }
    };
    // 类似实现reject...
  }
}

这个实现让我恍然大悟：原来状态管理不是简单的变量赋值，而是需要通过条件判断和回调队列来实现安全的变更通知。

二、异步之谜：微任务队列的真相

第二个让我困惑的问题是：为什么Promise的回调总是先于setTimeout执行？这涉及到JavaScript的事件循环机制。通过手写实现，我深入理解了微任务（Microtask）和宏任务（Macrotask）的区别。

在实现.then()方法时，我发现不能直接同步执行回调，否则会破坏异步链的预期行为。正确的做法是将回调推入微任务队列：

then(onFulfilled, onRejected) {
  return new MyPromise((resolve, reject) => {
    const handleFulfilled = (value) => {
      try {
        if (typeof onFulfilled === 'function') {
          resolve(onFulfilled(value));
        } else {
          resolve(value);
        }
      } catch (error) {
        reject(error);
      }
    };
    if (this.state === 'fulfilled') {
      queueMicrotask(() => handleFulfilled(this.value));
    } else if (this.state === 'pending') {
      this.onFulfilledCallbacks.push(() => 
        queueMicrotask(() => handleFulfilled(this.value))
      );
    }
    // 类似处理rejected状态...
  });
}

这里的关键是queueMicrotaskAPI，它比setTimeout具有更高的优先级。这个实现让我真正理解了为什么Promise回调总是优先执行——因为它们被放入了微任务队列，而微任务会在当前调用栈清空后立即执行。

三、链式调用的魔法：返回值处理

Promise最强大的特性之一是链式调用。但实现这个特性时，我遇到了第三个难题：如何处理then方法的返回值？通过研究规范，我发现需要区分三种情况：

1. 返回普通值：创建新的fulfilled状态的Promise
2. 返回另一个Promise：等待其决议
3. 抛出异常：创建rejected状态的Promise

这需要复杂的返回值解析逻辑：

const handleResolvedValue = (value) => {
  if (value instanceof MyPromise) {
    return value.then(resolve, reject);
  }
  try {
    const x = onFulfilled(value);
    resolvePromise(promise2, x, resolve, reject);
  } catch (error) {
    reject(error);
  }
};
function resolvePromise(promise2, x, resolve, reject) {
  if (promise2 === x) {
    return reject(new TypeError('Chaining cycle detected'));
  }
  let called = false;
  if (x !== null && (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);
          },
          r => {
            if (called) return;
            called = true;
            reject(r);
          }
        );
      } else {
        resolve(x);
      }
    } catch (error) {
      if (called) return;
      called = true;
      reject(error);
    }
  } else {
    resolve(x);
  }
}

这段代码揭示了Promise链式调用的核心机制：通过递归解析返回值，确保异步操作的正确传递。这让我彻底理解了为什么Promise.resolve(Promise.resolve(1))会返回一个值为1的fulfilled Promise。

四、错误处理的精髓：捕获所有异常

实现.catch()方法时，我遇到了最后一个关键问题：如何确保所有阶段的错误都能被捕获？通过研究，我发现需要建立完整的错误传播机制：

1. executor函数中的错误需要被捕获
2. then回调中的错误需要被捕获
3. 链式调用中的错误需要传递

解决方案是使用try-catch包裹所有可能抛出异常的代码块：

class MyPromise {
  constructor(executor) {
    try {
      executor(this.resolve, this.reject);
    } catch (error) {
      this.reject(error);
    }
  }
  then(onFulfilled, onRejected) {
    return new MyPromise((resolve, reject) => {
      const handleRejected = (reason) => {
        try {
          if (typeof onRejected === 'function') {
            resolve(onRejected(reason));
          } else {
            reject(reason);
          }
        } catch (error) {
          reject(error);
        }
      };
      // 类似处理fulfilled状态...
    });
  }
}

这种设计让我认识到：Promise的错误处理不是简单的try-catch，而是需要建立一套完整的错误传播机制，确保任何阶段的异常都能被最终捕获。

五、顿悟时刻：Promise的核心设计哲学

通过完整实现一个Promise类，我最终领悟到其设计精髓：

1. 状态不可变性：一旦状态改变，就不能再次修改，这保证了异步操作的可预测性
2. 异步通知机制：通过微任务队列实现高效的异步回调
3. 值穿透特性：then方法可以跳过中间步骤，直接传递值
4. 错误冒泡：未处理的错误会一直传递到链的末端

这些设计原则不仅解释了Promise的各种行为，也为我理解更复杂的异步模式（如async/await）打下了坚实基础。现在，当我看到这样的代码：

async function fetchData() {
  try {
    const response = await fetch('/api/data');
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Fetch failed:', error);
    throw error;
  }
}

我能清晰看到背后Promise的运作机制：async函数被编译为状态机，await表达式被转换为Promise链，错误处理通过try-catch与Promise的catch方法无缝对接。

手写Promise的过程，就像是一次代码考古之旅。通过逐层剥离其神秘面纱，我不仅掌握了异步编程的核心原理，更培养了对JavaScript运行时机制的深刻理解。这种从混沌到顿悟的体验，正是技术成长的精髓所在。对于任何希望深入理解JavaScript异步编程的开发者，我强烈建议尝试手写一个Promise实现——这个过程中的每一个困惑与突破，都将成为你技术成长的宝贵财富。