前言
上次我们手写了一个promise，相信大家已经对 Promise 有了深度的理解，这次我们再把 Promise 的所有相关方法都实现一下。
Promise.prototype.catch
Promise.prototype.catch = function(onRejected) {
return this.then(null, onRejected)
}
catch 方法相对简单，就是调用 promise 自身的 then 方法，只传入失败的回调。因为 then 方法本身具有值的传递性，所以我们只需传入失败的回调即可，即使没有成功的回调，也会将值自动的传递下去。
Promise.prototype.finally
无论成功还是失败都会执行 finally
Promise.prototype.finally = function(onFinished) {
return this.then(val => {
onFinished()
return val
}).catch((err) => {
onFinished()
return err
})
}
finally 需要注意
finally 的回调没有参数
promise 如果成功，则将成功的值正常传递下去，不会因 finally 而断掉，举例：
promise 如果失败，同上
Promise
.resolve(1)
.finally(val => console.log(val)) // undefind
.then(val => console.log(val)) // 1
Promise
.reject('error')
.finally(val => console.log(val)) // undefind
.catch(err => console.log(err)) // error
Promise.resolve
返回一个成功的 promise
Promise.resolve = function(val) {
return new Promise(resolve => {
resolve(val)
})
}
emmm 一眼就懂
Promise.reject
返回一个失败的 promise
Promise.reject = function(val) {
return new Promise((resolve, reject) => {
reject(val)
})
}
啥也不说了。。。
Promise.all
返回一个 promise 实例。接受一个可迭代的对象，会等 iterable 参数内所有的 promise 都 resolved 时被 reslove，如果有一个 rejected，则此实例被 reject。
如果 iterable 没有 promise，则此实例直接被 resolve。
返回值是一个数组，数组的值按照 iterable 的迭代顺序排列。
Promise.all = function(ps) {
let resolve
let reject
const promise = new Promise((r, j) => {
resolve = r
reject = j
})
let fufilledCount = 0
let index = 0;
const ret = [];
const wrapFufilled = i => {
return val => {
fufilledCount += 1
ret[i] = val
if (fufilledCount >= index) {
resolve(ret)
}
}
}
const wrapRejected = i => {
return err => {
reject(err)
}
}
for (let p of ps) {
Promise.resolve(p).then(wrapFufilled(index), wrapRejected(index))
index += 1
}
return promise
}
注意几个要点
因为接受的是一个可迭代对象（iterable），所以我们用 for of 遍历。
这里我们用 Promise.resolve() 包装一下所有的 promise。
wrapFufilled 的目的是为了记录当前遍历的 index。
Promise.race
返回一个 promise，一旦迭代器中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。
Promise.race = function(ps) {
let resolve
let reject
const promise = new Promise((r, j) => {
resolve = r
reject = j
})
for (let p of ps) {
Promise.resolve(p).then(
val => resolve(val),
err => reject(err)
)
}
return promise
}
Promise.any
只要其中的一个 promise 成功，就返回那个已经成功的 promise 。如果可迭代对象中没有一个 promise 成功（即所有的 promises 都失败/拒绝），就返回一个失败的 promise 和AggregateError类型的实例，它是 Error 的一个子类，用于把单一的错误集合在一起。
本质上，这个方法和Promise.all()是相反的
Promise.any = function(ps) {
let resolve
let reject
const promise = new Promise((r, j) => {
resolve = r
reject = j
})
let errCount = 0
let pCount = 0
for (let p of ps) {
pCount += 1
Promise.resolve(p).then(
val => resolve(val),
err => {
errCount += 1
if (errCount >= pCount) {
reject(new AggregateError('All promises were rejected'))
}
}
)
}
return promise
}
Promise.allSettled
返回一个在所有给定的promise都已经fulfilled或rejected后的promise，并带有一个对象数组，每个对象表示对应的promise结果。
这里举一个例子：
const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
const promises = [promise1, promise2];
Promise.allSettled(promises).
then((results) => results.forEach((result) => console.log(result)));
// 输出结果
// Object { status: "fulfilled", value: 3 }
// Object { status: "rejected", reason: "foo" }
具体实现：
Promise.allSettled = function(ps) {
let resolve
let reject
const promise = new Promise((r, j) => {
resolve = r
reject = j
})
let finishedCount = 0
let index = 0;
const ret = [];
const wrapFufilled = i => {
return val => {
finishedCount += 1
ret[i] = {
status: 'fufilled',
value: val
}
if (finishedCount >= index) {
resolve(ret)
}
}
}
const wrapRejected = i => {
return err => {
finishedCount += 1
ret[i] = {
status: 'rejected',
value: err
}
if (finishedCount >= index) {
resolve(ret)
}
}
}
for (let p of ps) {
Promise.resolve(p).then(wrapFufilled(index), wrapRejected(index))
index += 1
}
return promise
}