从实现一个Promise说起

前言

const p = new Promise((resolve, reject) => {
  console.log('A')
  setTimeout(() => {
    console.log('B')
    resolve('C')
  })
})

p.then(res => {
  console.log(res)
})

// A B C D

尽管工作中用了无数次Promise async await,但是在写下这篇文章之前,却不知道Promise背后发生了些什么,我一直以为的逻辑是先等待Promise构造方法中的异步函数完成后,再调用then方法执行其中的函数。然而事情并没有这么简单,这篇文章将以深入浅出的方式理解Promise背后究竟发生了什么

构造一个Promise

按照Promise/A+规范,一个Promise应该包含以下数据结构

interface IPromise {
  status: STATUS // 表明当前Promise的状态,不可逆,在进行then添加方法时,会根据这个状态做出不同的处理
  value: any // 异步函数执行成功后返回的值
  reason: any // 异步函数执行失败后返回的值
  onResolvedCallbacks: Function[] // 保存then方法添加的成功后执行函数
  onRejectCallbacks: Function[] // 保存then方法添加的失败后的执行函数
}

enum STATUS {
  PENDING,
  FULFILLED,
  REJECTED
}

接着动手实现一个Promise,因为在TS环境中Promise已经有了,为了避免和已有的冲突,我把自己构造的对象命名为MyPromise

class MyPromise {
  private status: STATUS
  private value: any
  private reason: any
  private onResolvedCallBacks: Function [] = []
  private onRejectCallBacks: Function [] = []

  constructor(executor: Function) {
    const self = this
    function resolve(value: any) {
      // 改变当前Promise的状态
      if (p.status === STATUS.PENDING) {
        p.stats = STATUS.FULFILLED
        p.value = value
        p.onResolveCallbacks.forEach(fun => {
          fun(p.value)
        })
      }
    }
    function reject(reason: any) {
      if (p.status === STATUS.PENDING) {
        p.status = STATUS.REJECTED
        p.reason = reason
        p.onRejectCallbacks.forEach(fun => fun(reason))
      }
    }
  }

  public then(onFulfilled: Function, onReject?: Function) {
    this.onResolveCallbacks.push(onFulfilled)
    if (onReject) {
      this.onRjectCallback.push(onRject)
      return
    }
    return this
  }
}

这是一个最最基本的Promise实现,写到这里我们试着从代码中了解下Promise究竟干了些什么。 我们知道JS是异步非阻塞单线程的语言,遇到异步任务时,将会向事件队列添加一个函数,直到异步任务完成时,线程再执行这个函数,基于此,在JS中很多地方用到了订阅者模式。

Promise正好是一个订阅者模式的实现executor就是我们添加的订阅的数据源,我们向这个源注册了两个钩子resolve, reject,分别在异步事件的成功和失败时执行,相当于订阅者的notify方法。

then方法则是向订阅者注册事件。这样就能初步理解Promise干了什么。

resolve,reject方法的改进

按照Promise预期的设计,then方法时同步的向Promise的待处理队列添加函数,而executor函数则是异步的执行一个函数,再调用其中的resolve或者reject方法,也就是说then一定先于executor执行。上面的代码中如果executor是一个同步的方法,那么新建这个MyPromise实例时,resolve就已经被调用了,导致then添加的方法无法执行。所以我们需要做出一定的处理,保证resolve之前,已经注册了事件处理函数

function reject (value: any) {
  // 调用setImmediate方法,保证resolve一定会在通过then同步的注册的方法后调用
  // setImmediate将会把回调中的函数加入到下一个task,优先级要比setTimeout高
  // JS中的Promise.resolve方法时将回调中的函数加入到当前的microtask队列,优先级要比前者高
  setImmediate(() => {
    if (p.status === STATUS.PENDING) {
      p.stats = STATUS.FULFILLED
      p.value = value
      p.onResolveCallbacks.forEach(fun => {
        fun(p.value)
      })
    }
  })
}

then方法中添加Promise的链式调用

之前的MyPromise通过then方法注册事件后,虽然返回了this能够进行链式调用,但是如果注册的事件返回的是Promise,包含异步的事件则会出错。针对这种状况我们需要进行特殊的处理

public then (onFulfilled: Function, onReject?: Function) {
  // 包装一个Promise
  let promise2: MyPromise
  // 保存当前this——外部的Promise
  const self: MyPromise = this
  // 如果当前异步函数执行成功,得到了值
  if (this.status === STATUS.FULFILLED) {
    // 声明一个新的 promise2
    promise2 = new MyPromise((resovle, reject) => {
      setImmediate(() => {
        try {
          // then添加的方法返回一个promise
          let res = onFulfilled(self.value)
          resolvePromise(promise2, res, resovle, reject)
        } catch (error) {
          reject(error)
        }
      })
    })
  }

  if (this.status === STATUS.PENDING) {
    promise2 = new MyPromise((reslove, reject) => {
      self.onResolveCallbacks.push(value => {
        try {
          let res = onFulfilled(value)
          resolvePromise(promise2, res, reslove, reject)
        } catch (error) {
          reject(error)
        }
      })
      self.onRejectCallbacks.push(reason => {
        try {
          let res = onReject(reason)
          resolvePromise(promise2, res, reslove, reject)
        } catch (error) {
          reject(error)
        }
      })
    })
  }

  function resolvePromise (promise: MyPromise, res: any, resolve: Function, reject: Function) {
    // 暂时不清楚什么情况下会出现循环应用
    if (promise === res) {
      return reject(new TypeError('循环引用'))
    }
    let then
    let called
    
    // 如果onFulfilled方法返回的res不为空,并且可能是object(可能是一个Promise或者一般对象)或者function
    if (res !== null && ((typeof res === 'object' || typeof res === 'function'))) {
      try {
        then = res.then
        // 如果res具有then属性,并且是一个function,说明可能是一个Promise(这里应该用类型判断)
        if (typeof then === 'function') {
          // 重复调用then方法, 直到res不再是一个Promise
          then.call(res, function (res2) {
            // 每次调用then方法都会返回一个新的Promise,如果当前的Promise已经注册过事件了,将会直接return
            if (called) return
            called = true
            resolvePromise(promise, res2, resolve, reject)
          }, function (err) {
            if (called) return
            called = true
            reject(err)
          })
        } else {
          // 调用resolve
          resolve(res)
        }
      } catch (error) {
        if (called) return
        called = true
        reject(error)
      }
    } else {
      resolve(res)
    }
  }
  
  return promise2
}

改进后的then方法改进了两个地方

  1. 判断通过then方法注册事件时Promise的状态,一个Promise的状态应该是确定的不可逆的,即只能从PENDING状态转换为fulfilled或者reject,当调用then方法注册事件时,如果此时这个Promise已经不是PENDING了,将会根据现在的Promise类型执行then注册的函数
  2. 每次调用then方法进行函数注册的时候都会返回一个新的Promise,这个Promise保证了then的链式调用。接着我们考虑了注册的onFulfilled函数,如果这个函数返回的是一个Promise,则继续向它注册事件

小结

  1. Promise本质就是一个发布订阅模式,异步函数是整个模型的驱动器,完成时调用resolve执行成功方法,then是向该模型注册事件
  2. Promise巧妙的利用发布订阅模式,将异步事件的发生与发生之后的执行解耦了,通过resolve钩子触发注册的函数,使得我们的关注点在then之后的方法
  3. Typescript用起来真是爽

这篇文章只是简单的介绍了Promise背后执行的原理,还有Promise.all Promise.race方法没有实现,不过已经不重要了,我们只需要记得Promise是一个发布订阅模式就OK,generator和 async await的方法也没有实现。不过基于此,可以大胆的猜测。通过await执行的Promise,是将原本resolve我们注册的函数改为了执行await方法中的函数,再把值取出来给我们调用。大抵应该是这个原理。实现上需要写一个generator runtime这也超过大部分人的能力。因此能够用好async await就好了。

本文的源代码在 Github 欢迎star

本文参考自文章 确认过眼神,你就是我的Promise~~

以上都是我瞎编的

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏思考的代码世界

Python编程从入门到实践之函数2|第9天

向函数传递列表很有用,这种列表包含的可能是名字、数字或更复杂的对象(如字典)。将列表传递给函数后,函数就能直接访问其内容。

3567
来自专栏影子

jQuery中的常用内容总结(三)

992
来自专栏光变

3.3 ASM-方法-工具类

‘org.objectweb.asm.commons’包含了一些预定义的方法适配器,可以用来定义自己的适配器。 本节介绍三个工具类,并且会展示它们如何和3.2....

650
来自专栏影子

jQuery中的常用内容总结(三)

转载请注明地址:http://www.cnblogs.com/funnyzpc/p/7571998.html

771
来自专栏Java帮帮-微信公众号-技术文章全总结

Java面试系列2

六、&和&&的区别? &是位运算符,表示按位与运算,&&是逻辑运算符,表示逻辑与(and) 七、swtich是否能作用在byte上,是否能作用在long上,是否...

2726
来自专栏python3

python3--面向对象--综合练习

3  解释生成器(generator)与函数的不同,并实现且使用简单generator

712
来自专栏PHP实战技术

你真的懂let和const吗?

在ES6之前我们脑海里应该只存在全局作用域和函数级作用域,没有块级作用域。那么为什么要引入块级作用域呢?

35811
来自专栏我是攻城师

在Scala里面如何使用元组

3344
来自专栏不止是前端

从实现一个Promise说起

尽管工作中用了无数次Promise async await,但是在写下这篇文章之前,却不知道Promise背后发生了些什么,我一直以为的逻辑是先等待Promis...

1364
来自专栏Java帮帮-微信公众号-技术文章全总结

Java面试系列9

✎一、Java有没有goto? java中的保留字,现在没有在java中使用。 ✎二、必须要知道的运行时异常 ArithmeticException 是...

2524

扫码关注云+社区