🦌鹿心雨的小窝🦌
🦌鹿心雨的小窝
coverPiccoverPic

实现 Promise A+ 规范的 Promise

异步PromiseJavaScript

前言

之前找工作的时候凭感觉做了一个实现 Promise A+ 规范的 Promise的练习，最近在准备新的工作机会，又看到了这个面试题。

我感觉之前的实现有很大优化空间。之前用前次调用结果作为标记来实现 Promise 多次 resolve 和 reject 触发的正确逻辑，感觉有点太麻烦了，通过和 AI 的深入交流，发现完全可以用简单的布尔值标记做到。

这篇博客是前文的优化版，包含了前文已有的 Promise A+ 的一些介绍，权当是复习吧…

前文看这里：https://deer.shika-blog.xyz/web/article/108 (各种错误有点多)

简介 Promise A+ 规范

变量和术语

Promise 表示异步操作的最终结果。

  1. Promise 具有 3 种状态：pending（等待中）、fulfilled（成功执行）、rejected（失败拒绝），初始状态为 pending，切换为 fulfilled 或者 rejected 后就不能再转换。处于非 pending 状态时称为 settled。
ts
  1. const testPromise = new Promise((resolve, reject) => {
  2.   // DO SOMETHING
  3. })

像这样子，传入的函数我们称为executor，resolve和reject会触发 Promise 的状态改变以及数据更新。

value表示成功执行（fulfilled 状态）的 Promise 的结果，reason表示失败拒绝（rejected 状态）的 Promise 的原因，它们可以取 JS 中任何合法的值。

Promise A+ 规范的 Promise 上的方法只有简单的then，catch、finally之类的方法并不包含。

graph
    A[创建Promise] --> B["执行executor(resolve, reject)"]
    
    
    F{"executor执行结果?"}
    C -->|settled|G[忽略重复调用]
    C -->|not settled|E
    B --> F
    
    F -->|"调用resolve(value)"| I{"Promise settled?"}
    I -->|settled|G
    I -->|not settled| D["状态: pending → fulfilled
存储value"]
    
    F -->|抛出异常| C
    F -->|"调用reject(reason)"| C{"Promise settled?"}
    E["状态: pending → rejected
存储reason"]
    

    F -->|"当前未执行resolve和reject，没有抛出异常"| H[pending]
    
    style A fill:#e1f5ff
    style B fill:#e1f5ff

then 方法

  1. then方法具有onFulfilled和onRejected两个入参，返回一个 Promise（链式调用）。

举个栗子：

ts
  1. const temp = testPromise.then(function onFulfilled (value) {
  2.   // DO SOMETHING
  3. }, function onRejected (reason) {
  4.   // DO SOMETHING
  5. })
  6. console.log(temp instanceof Promise) // true
  7. console.log(temp === testPromise) // false

  • Promise 从 pending 状态切换到 fulfilled 或者 rejected 时，执行此前then传入的onFulfilled或onRejected。fulfilled 状态的 Promise 会执行then传入的onFulfilled，rejected 状态的 Promise 会执行then传入的onRejected。

  • 执行onFulfilled或onRejected的结果会被传入新的 Promise temp的resolve方法中，如果发生了错误则传入reject中，改变的状态和数据。

  • onFulfilled或者onRejected不是函数时，返回的 Promise 与原 Promise 具有相同的状态和数据（传值穿透）。

用一个流程图总结一下：

graph 
    
    F["调用promise.then(onFulfilled, onRejected)"] --> G{"当前状态?"}
    
    G -->|pending| H["注册回调到队列
等待状态改变"]
    G -->|fulfilled| I["异步执行onFulfilled(value)"]
    G -->|rejected| J["异步执行onRejected(reason)"]
    
    I --> K{"onFulfilled返回值?"}
    J --> L{"onRejected返回值?"}
    
    K -->|正常返回| M["Promise Resolution Procedure"]
    L -->|正常返回| M
    K -->|抛出异常| O["调用新Promise的reject
状态: rejected"]
    L -->|抛出异常| O
    
    H -->|状态变为fulfilled| I
    H -->|状态变为rejected| J
    
    O --> Z[返回新Promise]

    style F fill:#fff2e1
    style G fill:#f0e1ff
    style M fill:#e8f5e9
    style H fill:#fff9c4

Promise Resolution Procedure

  1. resolve被触发时发生什么事了？此时 Promise 的状态仍未真正变化，会进入一段处理程序，规范称之为 Promise Resolution Procedure，主要逻辑是如果传入的是非 thenable 对象或者基本类型则直接修改 Promise 的状态和数据，是 thenable 就执行下面 thenable 相关逻辑。
  • 此外，不支持我返回我自己，onFulfilled或者onRejected返回该then返回的 Promise 时，抛出TypeError错误，例如：
ts
  1. const temp = testPromise.then(function onFulfilled (value) {
  2.   return temp
  3. })

处理 thenable 对象

  1. thenable 的对象是具有then方法的对象或者函数。then方法接受两个回调函数onResolvePromise和onRejectPromise，类似于这里的 Promise 的then。thenable 实际上包括实现了 Promise A+ 规范的 Promise，例如 ES6 原生的 Promise。举个 thenable 对象的栗子：
ts
  1. const thenable = {
  2.   then: function (onResolvePromise, onRejectPromise) {
  3.     onResolvePromise('miao~~')
  4.   }
  5. }

  • 如果触发了onFulfilled，返回了一个 thenable。如果是该 Promise 的实例，不是当前 Promise，则传入当前 Promise 的resolve和reject，调用then方法。

  • 兼容其他 thenable：调用then方法，传入当前 Promise 的resolve和reject，像该 Promise 实例一样解析。

  • 允许其他 thenable 对象乱写，这里需要处理 thenable 对象重复触发onResolvePromise或/和onRejectPromise的情况，这两个回调函数最多只能改变 1 次 Promise 的状态。

  1. 其他详细见 Promise A+ 规范。

这里再用个流程图总结一下

graph 
    M["Promise Resolution Procedure"]
    
    M --> P{返回值是thenable?}
    P -->|是| Q{是否返回自身?}
    Q -->|是| R[抛出TypeError]
    Q -->|否| S["调用thenable.then(resolvePromise, rejectPromise)"]
    
    P -->|否| N
    
    S --> T{thenable行为?}
    T -->|"调用resolvePromise(x)"| U{Promise settled?}
    T -->|"调用rejectPromise(reason)"| V{Promise settled?}
    T -->|抛出异常| O[调用新Promise的reject
状态: rejected]
    
    U -->|not settled| W["状态: fulfilled
value = x"]
    V -->|not settled| X["状态: rejected
reason = reason"]
    U -->|settled| Y[忽略重复调用]
    V -->|settled| Y
    
    N[调用新Promise的resolve
状态: fulfilled] --> Z[返回新Promise]
    O --> Z
    W --> Z
    X --> Z
    R --> AA["返回rejected Promise
reason = TypeError"]

    style M fill:#e8f5e9

前期准备

先定义好类型和一个发起微任务的辅助函数。

ts
  1. enum PromiseState {
  2.   fulfilled = 'fulfilled',
  3.   pending = 'pending',
  4.   rejected = 'rejected'
  5. }
  7. type Executor<T> = (
  8.   resolve: (value: T | PromiseLike<T>) => void,
  9.   reject: (reason?: any) => void
  10. ) => void
  12. const scheduleMicrotask = (callback: () => void) => {
  13.   if (typeof queueMicrotask === 'function') {
  14.     queueMicrotask(callback)
  15.   } else if (typeof process !== 'undefined' && process.nextTick) {
  16.     process.nextTick(callback)
  17.   } else {
  18.     Promise.resolve().then(callback)
  19.   }
  20. }

简单地写一个 Promise

ts
  1. class ShikaPromise<T = any> {
  2.   private state: PromiseState = PromiseState.pending
  3.   private value: T | undefined
  4.   private reason: any
  5.   constructor(executor: Executor<T>) {
  6.     try {
  7.       executor(
  8.         (value) => this.resolve(value),
  9.         (reason) => this.reject(reason)
  10.       )
  11.     } catch (error) {
  12.       this.reject(error)
  13.     }
  14.   }
  15.   private resolve(value: T): void {
  16.     // 不支持 resolve 自己
  17.     if (value === this) {
  18.       this.reject(new TypeError('Cannot resolve promise with itself'))
  19.       return
  20.     }
  21.     
  22.     scheduleMicrotask(() => {
  23.       this.state = PromiseState.fulfilled
  24.       this.value = value
  25.     })
  26.   }
  27.   private reject(reason: any): void {
  28.     scheduleMicrotask(() => {
  29.       this.state = PromiseState.rejected
  30.       this.reason = reason
  31.     })
  32.   }
  33.   then<TResult1 = T, TResult2 = never>(
  34.     onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined,
  35.     onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined
  36.   ) {
  37.     // TODO
  38.   }
  39. }

下面就来写then方法实现异步的链式调用。

then 方法

then返回一个 Promise，虽然 Promise A+ 规范没有说明需要返回的 Promise 不能和原有的是同一个，但是考虑到后续链式调用也会涉及到 Promise 状态的改变，所以这里就返回一个新的 Promise。

fulfilled 和 rejected 状态

假设const promise2 = promise1.then(onFulfilled, onRejected)，调用promise1.then时创建一个新的 Promise promise2返回出去。用过 ES6 的Promise很好理解，如果原有promise1是 fulfilled 的，则在新的promise2的executor中的resolve传入onFulfilled的结果，如果promise1处于失败状态，rejected 了，则在promise2的resolve中传入onRejected的结果。

举个栗子：

ts
  1. const promiseTmp1 = Promise.resolve('ok').then(value => value, reason => reason)
  2. // 此时 promiseTmp1.value 是 'ok'
  3. const promiseTmp2 = Promise.resolve('error').then(value => value, reason => reason)
  4. // 此时 promiseTmp2.value 是 'error'

下面编写 fulfilled 和 rejected 状态的处理逻辑。

ts
  1. // ...
  3. class ShikaPromise {
  4.   // ...
  5.   then<TResult1 = T, TResult2 = never>(
  6.     onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined,
  7.     onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined
  8.   ): ShikaPromise<TResult1 | TResult2> {
  9.     return new ShikaPromise<TResult1 | TResult2>((resolve, reject) => {
  10.       const handleCallback = (isFulfilled: boolean) => {
  11.         scheduleMicrotask(() => {
  12.           const callback = isFulfilled ? onFulfilled : onRejected
  13.           const data = isFulfilled ? this.value : this.reason
  14.           // 传值穿透
  15.           if (typeof callback !== 'function') {
  16.             if (isFulfilled) {
  17.               resolve(data as TResult1)
  18.             } else {
  19.               reject(data)
  20.             }
  21.             return
  22.           }
  24.           try {
  25.             const result = callback(data)
  26.             resolve(result)
  27.           } catch (error) {
  28.             reject(error)
  29.           }
  30.         })
  31.       }
  33.       switch (this.state) {
  34.         case PromiseState.fulfilled:
  35.           handleCallback(true)
  36.           break
  37.         case PromiseState.rejected:
  38.           handleCallback(false)
  39.           break
  40.         default:
  41.           // TODO
  42.       }
  43.     })
  44.   }
  45. }

pending 状态

promise1在等待的时候，可以在promise1上新建两个属性fulfilledHandlers、rejectedHandlers缓存给promise2触发resolve和reject的回调函数。promise2处于 pending 状态，promise1切换状态后触发这些回调函数，用来改变promise2的状态。

ts
  1. // ...
  2. class ShikaPromise {
  3.   // ...
  4.   // 记录等待 fulfilled 或者 rejected 后执行的回调函数
  5.   private fulfilledHandlers: Array<() => void> = []
  6.   private rejectedHandlers: Array<() => void> = []
  7.   // ...
  8.   private resolve(value: T): void {
  9.     scheduleMicrotask(() => {
  10.       this.state = PromiseState.fulfilled
  11.       this.value = value
  13.       const handlers = this.fulfilledHandlers.splice(0)
  14.       handlers.forEach((h) => h())
  15.     })
  16.   }
  17.   private reject(reason: any): void {
  18.     scheduleMicrotask(() => {
  19.       this.state = PromiseState.rejected
  20.       this.reason = reason
  22.       const handlers = this.rejectedHandlers.splice(0)
  23.       handlers.forEach((h) => h())
  24.     })
  25.   }
  26.   // ...
  27.   then (onFulfilled?: ThenCallback, onRejected?: ThenCallback) {
  28.     return new ShikaPromise<TResult1 | TResult2>((resolve, reject) => {
  29.       // ...
  30.       switch (this.state) {
  31.         // ...
  32.         default:
  33.           this.fulfilledHandlers.push(() => handleCallback(true))
  34.           this.rejectedHandlers.push(() => handleCallback(false))
  35.       }
  36.     })
  37.   }
  38. }

防止多次触发

我们通过添加标记isResolved记录是否已经触发resolve。当重复触发resolve和reject时，遇到isResolved为true就返回。

ts
  1. // ...
  2. class ShikaPromise<T = any> {
  3.   // ...
  4.   private isResolved = false
  5.   // ...
  7.   private resolve(value: T | PromiseLike<T>): void {
  8.     if (this.isResolved) return
  9.     
  10.     if (value === this) {
  11.       this.reject(new TypeError('Cannot resolve promise with itself'))
  12.       return
  13.     }
  14.     
  15.     // TODO: thenable 处理
  16.     this.fulfill(value as T)
  17.   }
  19.   private fulfill(value: T): void {
  20.     if (this.isResolved) return
  21.     this.isResolved = true
  22.     
  23.     scheduleMicrotask(() => {
  24.       this.state = PromiseState.fulfilled
  25.       this.value = value
  27.       const handlers = this.fulfilledHandlers.splice(0)
  28.       handlers.forEach((h) => h())
  29.     })
  30.   }
  32.   private reject(reason: any): void {
  33.     if (this.isResolved) return
  34.     this.isResolved = true
  35.     // ...
  36.   }
  37.   // ...
  38. }

解析 thenable 对象

如果遇到 thenable 对象，等待其进入 fulfilled 或者 rejected 状态，同样的，thenable 对象也需要防止重复进入 fulfilled 和 rejected 状态。

ts
  1. class ShikaPromise<T = any> {
  2.   // ...
  4.   private resolve(value: T | PromiseLike<T>): void {
  5.     // ...
  6.     const thenable = this.getThenable(value)
  7.     if (thenable) {
  8.       this.resolveThenable(thenable)
  9.     } else {
  10.       this.fulfill(value as T)
  11.     }
  12.   }
  13.   private getThenable(value: any): { then: Function; target: any } | null {
  14.     if (value !== null && (typeof value === 'object' || typeof value === 'function')) {
  15.       try {
  16.         // 在规范中有 Let then be x.then 的描述，测试用例中 value.then 只能被取一次
  17.         const then = value.then
  18.         if (typeof then === 'function') {
  19.           return { then, target: value }
  20.         }
  21.       } catch (error) {
  22.         this.reject(error)
  23.       }
  24.     }
  25.     return null
  26.   }
  28.   private resolveThenable(thenable: { then: Function; target: any }): void {
  29.     let called = false
  31.     try {
  32.       thenable.then.call(
  33.         thenable.target,
  34.         (value: any) => {
  35.           if (called) return
  36.           called = true
  37.           this.resolvevaluey)
  38.         },
  39.         (reason: any) => {
  40.           if (called) return
  41.           called = true
  42.           this.reject(reason)
  43.         }
  44.       )
  45.     } catch (error) {
  46.       if (!called) this.reject(error)
  47.     }
  48.   }
  49. }

其他方法

JS 的 Promise

下面就来实现一下 JS 的 Promse 的catch和finally。catch就是then方法只提供第二个参数。finally方法回调函数不接收任何参数，返回一个状态和数据与原来相同的 Promise。

ts
  1. class ShikaPromise {
  2.   catch<TResult = never>(
  3.     onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined
  4.   ): ShikaPromise<T | TResult> {
  5.     return this.then(null, onRejected)
  6.   }
  8.   finally(onFinally?: (() => void) | null | undefined): ShikaPromise<T> {
  9.     return this.then(
  10.       (value) => {
  11.         onFinally?.()
  12.         return value
  13.       },
  14.       (reason) => {
  15.         onFinally?.()
  16.         throw reason
  17.       }
  18.     )
  19.   }
  20. }

还有Promise.resolve和Promise.reject两个静态方法：

ts
  1. class ShikaPromise {
  2.   static resolve<T>(value: T | PromiseLike<T>): ShikaPromise<T> {
  3.     return value instanceof ShikaPromise ? value : new ShikaPromise((resolve) => resolve(value))
  4.   }
  5.   static reject<T = never>(reason?: any): ShikaPromise<T> {
  6.     return new ShikaPromise((_, reject) => reject(reason))
  7.   }
  8. }

如果 Promise 可以停止

如果想要 Promise 后面的then（catch、finally）都不会触发，这里只需要返回一个 pending 状态的 Promise。这里实现一个时链式调用停止的cancel方法和返回 pending 的 Promise 的wait方法：

ts
  1. class ShikaPromise {
  2.   static wait(): ShikaPromise<never> {
  3.     return new ShikaPromise(() => {})
  4.   }
  5.   cancel(): ShikaPromise<never> {
  6.     return new ShikaPromise(() => {})
  7.   }
  8. }

Promise A+ 测试

下载 promises-aplus-tests 包：

cmd
  1. npm i promises-aplus-tests

要求 Promise 所在文件采用 commonjs 方式导出。还需要在 Promise 上实现静态方法：

ts
  1. class ShikaPromise {
  2.   static deferred<T>() {
  3.     let resolve!: (value: T | PromiseLike<T>) => void
  4.     let reject!: (reason?: any) => void
  6.     const promise = new ShikaPromise<T>((res, rej) => {
  7.       resolve = res
  8.       reject = rej
  9.     })
  11.     return { promise, resolve, reject }
  12.   }
  13. }

promises-aplus-tests Promise 的所在文件即可运行，如果你在用 TS，文件为编译后的文件，例如：

cmd
  1. promises-aplus-tests dist/文件名.js

Promise A+ 的测试用例覆盖面非常全，调试时烦死了x，通过了所有 817 条用例，就说明你的 Promise 实现了 Promise A+ 标准了。

我把 TS 编译和运行测试用例在 package.json 组装成一条命令：

json
  1. {
  2.   // ...
  3.   "scripts": {
  4.     // ...
  5.     "test": "tsc && promises-aplus-tests dist/文件名.js",
  6.   },
  7.   // ...
  8. }

这里 tsc 会默认编译 tsconfig.json 设置的根目录（这里是 ./src），然后放到输出目录中（这里是 ./dist）。

最终实现

ts
  1. enum PromiseState {
  2.   fulfilled = 'fulfilled',
  3.   pending = 'pending',
  4.   rejected = 'rejected'
  5. }
  7. type Executor<T> = (
  8.   resolve: (value: T | PromiseLike<T>) => void,
  9.   reject: (reason?: any) => void
  10. ) => void
  12. const scheduleMicrotask = (callback: () => void) => {
  13.   if (typeof queueMicrotask === 'function') {
  14.     queueMicrotask(callback)
  15.   } else if (typeof process !== 'undefined' && process.nextTick) {
  16.     process.nextTick(callback)
  17.   } else {
  18.     Promise.resolve().then(callback)
  19.   }
  20. }
  22. class ShikaPromise<T = any> {
  23.   private state: PromiseState = PromiseState.pending
  24.   private value: T | undefined
  25.   private reason: any
  26.   private fulfilledHandlers: Array<() => void> = []
  27.   private rejectedHandlers: Array<() => void> = []
  28.   private isResolved = false
  30.   constructor(executor: Executor<T>) {
  31.     try {
  32.       executor(
  33.         (value) => this.resolve(value),
  34.         (reason) => this.reject(reason)
  35.       )
  36.     } catch (error) {
  37.       this.reject(error)
  38.     }
  39.   }
  41.   private resolve(value: T | PromiseLike<T>): void {
  42.     if (this.isResolved) return
  44.     if (value === this) {
  45.       this.reject(new TypeError('Cannot resolve promise with itself'))
  46.       return
  47.     }
  49.     const thenable = this.getThenable(value)
  50.     if (thenable) {
  51.       this.resolveThenable(thenable)
  52.     } else {
  53.       this.fulfill(value as T)
  54.     }
  55.   }
  57.   private fulfill(value: T): void {
  58.     if (this.isResolved) return
  59.     this.isResolved = true
  61.     scheduleMicrotask(() => {
  62.       this.state = PromiseState.fulfilled
  63.       this.value = value
  65.       const handlers = this.fulfilledHandlers.splice(0)
  66.       handlers.forEach((h) => h())
  67.     })
  68.   }
  70.   private reject(reason: any): void {
  71.     if (this.isResolved) return
  72.     this.isResolved = true
  74.     scheduleMicrotask(() => {
  75.       this.state = PromiseState.rejected
  76.       this.reason = reason
  78.       const handlers = this.rejectedHandlers.splice(0)
  79.       handlers.forEach((h) => h())
  80.     })
  81.   }
  83.   private getThenable(value: any): { then: Function; target: any } | null {
  84.     if (value !== null && (typeof value === 'object' || typeof value === 'function')) {
  85.       try {
  86.         const then = value.then
  87.         if (typeof then === 'function') {
  88.           return { then, target: value }
  89.         }
  90.       } catch (error) {
  91.         this.reject(error)
  92.       }
  93.     }
  94.     return null
  95.   }
  97.   private resolveThenable(thenable: { then: Function; target: any }): void {
  98.     let called = false
  100.     try {
  101.       thenable.then.call(
  102.         thenable.target,
  103.         (value: any) => {
  104.           if (called) return
  105.           called = true
  106.           this.resolve(value)
  107.         },
  108.         (reason: any) => {
  109.           if (called) return
  110.           called = true
  111.           this.reject(reason)
  112.         }
  113.       )
  114.     } catch (error) {
  115.       if (!called) this.reject(error)
  116.     }
  117.   }
  119.   then<TResult1 = T, TResult2 = never>(
  120.     onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined,
  121.     onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined
  122.   ): ShikaPromise<TResult1 | TResult2> {
  123.     return new ShikaPromise<TResult1 | TResult2>((resolve, reject) => {
  124.       const handleCallback = (isFulfilled: boolean) => {
  125.         scheduleMicrotask(() => {
  126.           const callback = isFulfilled ? onFulfilled : onRejected
  127.           const data = isFulfilled ? this.value : this.reason
  129.           if (typeof callback !== 'function') {
  130.             if (isFulfilled) {
  131.               resolve(data as TResult1)
  132.             } else {
  133.               reject(data)
  134.             }
  135.             return
  136.           }
  138.           try {
  139.             const result = callback(data)
  140.             resolve(result)
  141.           } catch (error) {
  142.             reject(error)
  143.           }
  144.         })
  145.       }
  147.       switch (this.state) {
  148.         case PromiseState.fulfilled:
  149.           handleCallback(true)
  150.           break
  151.         case PromiseState.rejected:
  152.           handleCallback(false)
  153.           break
  154.         default:
  155.           this.fulfilledHandlers.push(() => handleCallback(true))
  156.           this.rejectedHandlers.push(() => handleCallback(false))
  157.       }
  158.     })
  159.   }
  161.   catch<TResult = never>(
  162.     onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined
  163.   ): ShikaPromise<T | TResult> {
  164.     return this.then(null, onRejected)
  165.   }
  167.   finally(onFinally?: (() => void) | null | undefined): ShikaPromise<T> {
  168.     return this.then(
  169.       (value) => {
  170.         onFinally?.()
  171.         return value
  172.       },
  173.       (reason) => {
  174.         onFinally?.()
  175.         throw reason
  176.       }
  177.     )
  178.   }
  180.   static resolve<T>(value: T | PromiseLike<T>): ShikaPromise<T> {
  181.     return value instanceof ShikaPromise ? value : new ShikaPromise((resolve) => resolve(value))
  182.   }
  184.   static reject<T = never>(reason?: any): ShikaPromise<T> {
  185.     return new ShikaPromise((_, reject) => reject(reason))
  186.   }
  188.   static wait(): ShikaPromise<never> {
  189.     return new ShikaPromise(() => {})
  190.   }
  192.   cancel(): ShikaPromise<never> {
  193.     return new ShikaPromise(() => {})
  194.   }
  196.   static deferred<T>() {
  197.     let resolve!: (value: T | PromiseLike<T>) => void
  198.     let reject!: (reason?: any) => void
  200.     const promise = new ShikaPromise<T>((res, rej) => {
  201.       resolve = res
  202.       reject = rej
  203.     })
  205.     return { promise, resolve, reject }
  206.   }
  207. }
  209. module.exports = ShikaPromise

结尾

这里实现了一个 Promise A+ 规范的 Promise，重新理解 Promise A+ 规范也修复了我以前对此的认识不足之处。

上一篇：Windows 系统把 Docker Desktop 装到 C 盘外的其他盘
下一篇：关于 HTTPS 的笔记 2.0
0 条评论未登录用户
Ctrl or + Enter 评论
© 2023-2025 LittleRangiferTarandus, All rights reserved.
🌸 Run