Repository navigation
Open
Labels
Description
Promise 是 ES6 中新增的引用类型。
在通过 new 创建 Promise 对象时,需要传入一个回调函数(executor)。
- 这个回调函数会立即执行,并且传入另两个回调函数
resolve、reject; - 当调用
resolve回调函数时,会执行Promise对象then方法传入的回调函数; - 当调用
reject回调函数时,会执行Promise对象的catch方法传入的回调函数。
3 种状态
- 待定
pending:执行executor中的代码时,处于该状态; - 已兑现
fulfilled:执行了resolve时,处于该状态; - 已拒绝
rejected:执行了reject时,处于该状态。
9 个方法
then:当调用resolve回调函数时,会执行;catch:当调用reject回调函数时,会执行;finally:无论是fulfilled状态,还是reject状态,它都会执行;resolve:相当于new Promise,并且执行resolve操作;reject:相当于new Promise,并且执行reject操作;all:将多个Promise包裹在一起形成一个新的Promise;allSettled:所有的Promise都有结果,才会有最终的状态;race:多个Promise相互竞争,谁先有结果,那么就使用谁的结果;any:等到一个fulfilled状态,才会决定新Promise的状态。如果所有的Promise都是reject的,那么会报一个AggregateError的错误。
手写 Promise 思路
一、Promise 类设计
class class HbsPromise {}二、构造函数的规划
class HbsPromise {
constructor(executor) {
// 定义状态
// 定义 resolve、reject 回调
// resolve 执行微任务队列:改变状态、获取 value、then 传入执行成功回调
// reject 执行微任务队列:改变状态、获取 reason、then 传入执行失败回调
// try catch
executor(resolve, reject)
}
}三、then 方法实现
class HbsPromise {
then(onFulfilled, onRejected) {
// 1. 判断 onFulfilled、onRejected,给默认值
// 2. 返回 Promise resolve/reject
// 3. 判断之前的 Promise 状态是否确定
// onFulfilled/onRejected 直接执行(捕获异常)
// 4. 添加到数组中 push(() => { 执行 onFulfilled/onRejected 直接执行代码 })
}
}四、catch 方法
class HbsPromise {
catch(onRejected) {
return this.then(undefined, onRejected)
}
}五、finally
class HbsPromise {
finally(onFinally) {
return this.then(() => { onFinally() }, () => { onFinally() })
}
}六、resolve/reject
class HbsPromise {
static resolve(value) {
return new HbsPromise(resolve => resolve(value))
}
static reject(reason) {
return new HbsPromise((resolve, reject) => reject(reason))
}
}七、all/allSettled
核心:要知道 new Promise 的 resolve、reject 在什么情况下执行。
all:
情况一:所有的都有结果;
情况二:有一个 reject。
allSettled:
情况:所有都有结果,并且一定执行 resolve。
八、race/any
race:
情况:只要有结果。
any:
情况一:必须等到一个 resolve 结果;
情况二:都没有 resolve,所有的都是 reject,报一个 AggregateError 的错误。
手写 Promise
const PROMISE_STATUS_PENDING = 'pending'
const PROMISE_STATUS_FULFILLED = 'fulfilled'
const PROMISE_STATUS_REJECTED = 'rejected'
// 工具函数
function execFunctionWithCatchError(execFn, value, resolve, reject) {
try {
const result = execFn(value)
resolve(result)
}
catch (err) {
reject(err)
}
}
class HbsPromise {
constructor(executor) {
this.status = PROMISE_STATUS_PENDING
this.value = undefined
this.reason = undefined
this.onFulfilledFns = []
this.onRejectedFns = []
const resolve = (value) => {
if (this.status === PROMISE_STATUS_PENDING) {
// 添加微任务
queueMicrotask(() => {
this.status = PROMISE_STATUS_FULFILLED
this.value = value
this.onFulfilledFns.forEach((fn) => {
fn()
})
})
}
}
const reject = (reason) => {
if (this.status === PROMISE_STATUS_PENDING) {
// 添加微任务
queueMicrotask(() => {
this.status = PROMISE_STATUS_REJECTED
this.reason = reason
this.onRejectedFns.forEach((fn) => {
fn()
})
})
}
}
try {
executor(resolve, reject)
}
catch (err) {
reject(err)
}
}
then(onFulfilled, onRejected) {
const defaultOnRejected = (err) => { throw err }
onRejected = onRejected || defaultOnRejected
const defaultOnFulfilled = (value) => { return value }
onFulfilled = onFulfilled || defaultOnFulfilled
return new HbsPromise((resolve, reject) => {
// 1. 如果在 then 调用的时候,状态已经确定下来
if (this.status === PROMISE_STATUS_FULFILLED) {
execFunctionWithCatchError(onFulfilled, this.value, resolve, reject)
}
if (this.status === PROMISE_STATUS_REJECTED) {
execFunctionWithCatchError(onRejected, this.reason, resolve, reject)
}
// 2. 将成功回调和失败回调放到数组中
if (this.status === PROMISE_STATUS_PENDING) {
this.onFulfilledFns.push(() => {
execFunctionWithCatchError(onFulfilled, this.value, resolve, reject)
})
this.onRejectedFns.push(() => {
execFunctionWithCatchError(onRejected, this.reason, resolve, reject)
})
}
})
}
catch(onRejected) {
return this.then(undefined, onRejected)
}
finally(onFinally) {
this.then(() => {
onFinally()
}, () => {
onFinally()
})
}
static resolve(value) {
return new HbsPromise(resolve => resolve(value))
}
static reject(reason) {
return new HbsPromise((resolve, reject) => reject(reason))
}
static all(promises) {
return new HbsPromise((resolve, reject) => {
const values = []
promises.forEach((promise, index) => {
promise.then((res) => {
values[index] = res
if (values.length === promises.length) {
resolve(values)
}
}, (err) => {
reject(err)
})
})
})
}
static allSettled(promises) {
return new HbsPromise((resolve) => {
const values = []
promises.forEach((promise, index) => {
promise.then((res) => {
values[index] = {
status: PROMISE_STATUS_FULFILLED,
value: res
}
if (values.length === promises.length) {
resolve(values)
}
}, (err) => {
values[index] = {
status: PROMISE_STATUS_REJECTED,
reason: err
}
if (values.length === promises.length) {
resolve(values)
}
})
})
})
}
static race(promises) {
return new HbsPromise((resolve, reject) => {
promises.forEach((promise) => {
promise.then(resolve, reject)
})
})
}
static any(promises) {
return new HbsPromise((resolve, reject) => {
const reasons = []
promises.forEach((promise, index) => {
promise.then(resolve, (err) => {
reasons[index] = err
if (reasons.length === promises.length) {
reject(new AggregateError(reasons))
}
})
})
})
}
}Reacted by luckept and 洪布斯
Activity
betteroneday commentedon Jun 9, 2022

前面那个判断能去掉吗,里面已经判断了嘛baboon-king commentedon Jun 9, 2022
支持 HBS & developer-plus🏅
补充一个答案
BaboonKing🙈
luckept commentedon Jun 9, 2022
先说结论,洪佬的是正确的,我这个版本比较简陋,细节上是有问题的,仅供大家参考一下哈哈哈,因为我写的 then 不是微任务,会导致执行顺序有问题,正常应该在 then 中先执行完所有同步代码,再去 resolve,我这个会碰到 resolve 就去执行依赖的触发
[-]手写题:Promise[/-][+]手写 Promise[/+]Hongbusi commentedon Jun 10, 2022
@luckept
可以在代码块加一个类型,使代码高亮。
luckept commentedon Jun 10, 2022
哈哈哈好!
[-]手写 Promise[/-][+]手写题:Promise[/+]