idea实现抽象类的所有抽象方法_Promise 所有方法实现

前言

上次我们手写了一个 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 需要注意

1. finally 的回调没有参数
2. promise 如果成功，则将成功的值正常传递下去，不会因 finally 而断掉，举例：
3. promise 如果失败，同上

Promise  .resolve(1)  .finally(val => console.log(val)) // undefind  .then(val => console.log(val)) // 1Promise  .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}

注意几个要点

1. 因为接受的是一个可迭代对象(iterable)，所以我们用 for of 遍历。
2. 这里我们用 Promise.resolve() 包装一下所有的 promise。
3. 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}

最后

如果这篇文章对你有帮助的话期望得到你的点赞~~~

本人会长期发布关于原理解读方面的文章，如果想深入了解 js 原生，框架底层的话可以关注我呀~~~