Promise 实现代码核心逻辑分析

Promise 是一种用于处理异步操作的编程模型，它通过承诺实现代码执行的未来状态。通过分析 Promise 的核心逻辑，我们可以深入理解其实现原理和应用场景。

Promise 核心逻辑

Promise 类的实现主要包括以下核心部分：

状态管理

Promise 实例具有三种状态：

pending：等待执行

fulfilled：成功状态

rejected：失败状态
通过这些状态，Promise 可以决定下一步操作。

执行器与回调

Promise 的执行器executor是接受两个回调函数resolve和reject。执行器会立即执行，参数为resolve和reject。

状态转换

resolve：将状态从pending切换为fulfilled

reject：将状态从pending切换为rejected
每个状态转换都伴随着特定的行为。

then 方法

.then() 方法用于定义成功或失败的回调函数，返回新的 Promise 实例。关键在于：

then 方法可链式调用，后续回调函数可接收前一个回调函数的返回值。

允许定义失败回调处理失败原因。

异步执行

使用 setTimeout 进行异步操作时，需注意回调函数的执行顺序。由于 Promise 是非阻塞的，then 方法可以在异步执行完成后处理回调。

错误处理

执行器中的错误会自动将状态切换为rejected。

失败回调在下一个.then() 中会继续传播错误。

Promise.all

用于处理多个 Promise 的同时执行，静态方法Promise.all() 接受一个数组，返回一个新的 Promise，等待所有子 Promise 完成后，才调用成功回调。

静态方法

Promise.resolve()：返回一个 Promise 实例，参数可为普通值或 Promise。

Promise.finally()：无论成功或失败，总会执行回调函数，常用于资源释放或后续处理。

Promise.catch()：定义失败回调，常用于错误处理。

代码实现

以下是 MyPromise 类的实现代码：

const MyPromise = class MyPromise {  constructor(executor) {    this.status = 'pending';    this.value = undefined;    this.reason = undefined;    this.successCallback = [];    this.failCallback = [];    try {      executor(this.resolve, this.reject);    } catch (e) {      this.reject(e);    }  }  // 状态管理  resolve(value) {    if (this.status !== 'pending') return;    this.status = 'fulfilled';    this.value = value;    const callbacks = this.successCallback;    for (let i = 0; i < callbacks.length; i++) {      callbacks[i]();    }  }  // 状态管理  reject(reason) {    if (this.status !== 'pending') return;    this.status = 'rejected';    this.reason = reason;    const callbacks = this.failCallback;    for (let i = 0; i < callbacks.length; i++) {      callbacks[i]();    }  }  // 回调链  then(successCallback, failCallback) {    // 处理默认值，支持链式调用    successCallback = typeof successCallback === 'function'       ? successCallback       : (value) => value;    failCallback = typeof failCallback === 'function'      ? failCallback       : (reason) => { throw reason; };    const promise2 = new Promise((resolve, reject) => {      switch (this.status) {        case 'fulfilled':          setTimeout(() => resolve Promise 组合处理逻辑);          break;        case 'rejected':          setTimeout(() => reject 部分处理逻辑);          break;        default:          // 存储回调并等待          this.successCallback.push(() => {            // 最终处理 Promise 组合结果            setTimeout(() => resolve Promise 组合结果);          });          this.failCallback.push(() => {            // 处理失败回调并继续传播错误          });          break;      }    });    return promise2;  }  // 其他静态方法和组合后的逻辑  catch (failCallback) {    return this.then(undefined, failCallback);  }  finally(callback) {    return this.then(value =>       MyPromise.resolve(callback()).then(() => value),      reason =>         MyPromise.resolve(callback()).then(() => { throw reason; })    );  }  // 其他静态方法  static all(array) {    // 其他的实现细节（如 array.reduce 等），不过列出不完整  }  static resolve(value) {    // 返回 MyPromise 实例，处理普通值或 Promise    if (value instanceof MyPromise) {      return value;    } else {      return new MyPromise(resolve => resolve(value));    }  }};

总结

通过以上实现，我们能够清晰地看到 Promise 的核心逻辑。从状态管理到回调链，通过一步步的处理，确保了异步操作的顺序和资源的正确释放。通过理解这些核心机制，我们可以更好地利用 Promise 提升代码的异步性和可读性。

转载地址：http://dzsnz.baihongyu.com/

你可能感兴趣的文章