1. 全栈程序员必看首页

Promise原理实现[通俗易懂]

全栈程序员-用户IM • • 未分类

Promise原理实现[通俗易懂]首先先看一下promise的调用方式：实现原理如下：详细解释如下：定义异步函数MyPromise，所以执行的函数也是MyPromise：首先看函数执行的方法：newMyPromi

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

首先先看一下 promise 的调用方式：

// 实例化 Promise：
  new MyPromise((resolve, reject) => {
    setTimeout(() => {
      resolve(1)  //这里相当于给value赋值
    }, 0)
  }).then(value => {
    console.log(value)
  })

实现原理如下：

const PENDING = 'pending'  //首先我们创建了三个常量用于表示状态，对于经常使用的一些值都应该通过常量来管理，便于开发及后期维护
const RESOLVED = 'resolved' 
const REJECTED = 'rejected' 

function MyPromise(fn) {
  const that = this  //在函数体内部首先创建了常量 `that`，因为代码可能会异步执行，用于获取正确的 `this` 对象
  that.state = PENDING   //一开始 `Promise` 的状态应该是 `pending`
  that.value = null    //`value` 变量用于保存 `resolve` 或者 `reject` 中传入的值
  that.resolvedCallbacks = []  
  that.rejectedCallbacks = []
  /*
  `resolvedCallbacks` 和 `rejectedCallbacks` 用于保存 `then` 中的回调，
  因为当执行完 `Promise` 时状态可能还是等待中，这时候应该把 `then` 中的回调保存起来用于状态改变时使用
  */
  function resolve(value) {
    if (that.state === PENDING) {
      that.state = RESOLVED
      that.value = value
      that.resolvedCallbacks.map(cb => cb(that.value))//map这里是执行回调函数
    }
  }
  
  function reject(value) {
    if (that.state === PENDING) {
      that.state = REJECTED
      that.value = value
      that.rejectedCallbacks.map(cb => cb(that.value))//map这里是执行回调函数
    }
  }
/*
*   首先两个函数都得判断当前状态是否为等待中，因为规范规定只有等待态才可以改变状态
*   将当前状态更改为对应状态，并且将传入的值赋值给 `value`
*   遍历回调数组并执行
*/
    try {
        fn(resolve, reject)
    } catch (e) {
        reject(e)
    }

}

MyPromise.prototype.then = function(onFulfilled, onRejected) {
    const that = this
    //首先判断两个参数是否为函数类型，因为这两个参数是可选参数
    //当参数不是函数类型时，需要创建一个函数赋值给对应的参数，同时也实现了透传
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : (v) => { return v }
    onRejected =
      typeof onRejected === 'function'
        ? onRejected
        : r => {
            throw r
          }
    //接下来就是一系列判断状态的逻辑，当状态不是等待态时，就去执行相对应的函数。
    //如果状态是等待态的话，就往回调函数中 `push` 函数，比如如下代码就会进入等待态的逻辑
    if (that.state === PENDING) {
      that.resolvedCallbacks.push(onFulfilled)//push这里是保存回调函数
      that.rejectedCallbacks.push(onRejected)
    }
    if (that.state === RESOLVED) {
      onFulfilled(that.value)
    }
    if (that.state === REJECTED) {
      onRejected(that.value)
    }
}

详细解释如下：

定义异步函数 MyPromise，所以执行的函数也是 MyPromise：
首先看 函数执行的方法： 
new MyPromise((resolve, reject) => {
  setTimeout(() => {
    resolve(1)
  }, 0)
})

函数的参数是： 
(resolve, reject) => {
  setTimeout(() => {
    resolve(1)
  }, 0)
}

对应着 
function MyPromise(fn){
    try {
      fn(resolve, reject) // 在这里执行了传入的参数fn(),并且把规定的 
      resolve, reject 两个参数传递到 fn 中。
    } catch (e) {
    reject(e)
    }
}

中的 fn，所以会执行这个传入的函数 fn(resolve, reject)；
传入的参数是异步的，会在同步代码结束后再去执行对应的 resolve(1)这个函数，
而这个函数已经在 MyPromise 中进行了定义： 
function resolve(value) {
    if (that.state === PENDING) {
      that.state = RESOLVED
      that.value = value
      that.resolvedCallbacks.map(cb => cb(that.value))//map这里是执行回调函数
    }
}

// 也就是会在同步代码之后再执行上面的函数，所以我们继续看 MyPromise 的调用 
new MyPromise((resolve, reject) => {
  //异步代码
}).then(value => {
  console.log(value)
})

接着执行方法： then()。而then 挂在了原型链上：
MyPromise.prototype.then = function(onFulfilled, onRejected) {  }
所以then包含两个参数，分别对对应 onFulfilled, onRejected。 如果没有定义需要做容错处理，
也就是给默认的函数参数： 
onFulfilled = typeof onFulfilled === ‘function’ ? onFulfilled : (v) => { return v } 
由于执行同步操作，此时state 还等于PENDING，所以执行：
  
if (that.state === PENDING) {
  that.resolvedCallbacks.push(onFulfilled)//push这里是保存回调函数
  that.rejectedCallbacks.push(onRejected)
}

也就是把 成功后操作函数和失败函数分别保存到对应的数组中。 
setTimeout(() => {
    resolve(1)
}, 0)

好了，接下来同步执行结束，然后开始执行异步操作： 
function resolve(value) {
  if (that.state === PENDING) {
    that.state = RESOLVED
    that.value = value
    that.resolvedCallbacks.map(cb => cb(that.value))//map这里是执行回调函数
  }
}

可以看到，先改变状态，再从保存数组中，获取到回调函数，再执行！
至此，在promise中 resolve(1) 告诉了执行回调的时机和参数。
而then规定的是异步之后的回调函数。
然后我们看到还在then函数中规定了其他的状态，解释一下：
如果执行函数中，没有异步处理： 
new MyPromise((resolve, reject) => {
  resolve(1)
}).then(value => {
  console.log(value)
})

也就是在定义中： 
try {
    fn(resolve, reject)
} catch (e) {
    reject(e)
}

直接执行了 fn()，根据传入的 resolve，reject。这里直接执行了 resolve： 
function resolve(value) {
  if (that.state === PENDING) {
    that.state = RESOLVED
    that.value = value
    that.resolvedCallbacks.map(cb => cb(that.value))//map这里是执行回调函数
  }
}

更改了状态，由于还没有执行then函数，保存函数没有数据，所以没有可以执行的回调函数。
接下来程序走到了then 
new MyPromise((resolve, reject) => {
  //同步代码
}).then(value => {
  console.log(value)
})

由于状态已经改变，所以执行： 
MyPromise.prototype.then = function(onFulfilled, onRejected) {
  if (that.state === RESOLVED) {
    onFulfilled(that.value)
  }
}

同样也做到了执行then传入的函数。
总结一下，如果 resolve 被放在了异步函数中，then传入的回调函数会先被保存下来，待异步函数执行完毕之后，
在次执行回调函数；
而如若 resolve 被放在了同步函数中，则回调函数数组为空，顺序执行到 then 函数，则会执行该回调函数。

 

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/167317.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号