实例方法

catch

finally

静态方法

reslove

reject

race

all

allSettled

any

实例方法

提供给promise实例的方法包括catch 与finally

catch

Promise 实例的 catch() 方法用于注册一个在 promise 被拒绝时调用的函数。它会立即返回一个等效的 Promise 对象，这可以允许你链式调用其他 promise 的方法。此方法是 Promise.prototype.then(undefined, onRejected) 的一种简写形式。

1 内部调用then方法（此方法是 Promise.prototype.then(undefined, onRejected) 的一种简写形式。）

2.处理异常因为是实例化生成前抛出的异常要 catch 捕获实例化生成函数执行前

   constructor(func) {const resolve = (result) => {if (this.state == PENDING) {this.state = FULFILLED;this.result = result;this.#handlers.forEach(({ onFulfilled }) => {onFulfilled(this.result);});}};const reject = (result) => {if (this.state == PENDING) {this.state = REJECTED;this.result = result;this.#handlers.forEach(({ onRejected }) => {onRejected(this.result);});}};try {func(resolve, reject);} catch (error) {reject(error);}}catch(onRejected) {return this.then(undefined, onRejected);}
// 测试代码const p = new MyPromise((resolve, reject) => {reject("error");// throw "error";// return p2;// return 2;// return new MyPromise((resolve, reject) => {//   resolve("OK");//   // reject("ERROR");// });
});
p.then((res) => {console.log("res:", res);
}).catch((error) => {console.log("err:", err);
});

finally

Promise 实例的 finally() 方法用于注册一个在 promise 敲定（兑现或拒绝）时调用的函数。它会立即返回一个等效的 Promise 对象，这可以允许你链式调用其他 promise 方法。

finally() 方法类似于调用 then(onFinally, onFinally)

这可以让你避免在 promise 的 then() 和 catch() 处理器中重复编写代码。

onFinally 回调函数不接收任何参数。这种情况恰好适用于你不关心拒绝原因或兑现值的情况，因此无需提供它。
如果你想在 promise 敲定时进行一些处理或者清理，无论其结果如何，那么 finally() 方法会很有用。

  finally(onFinally) {return this.then(onFinally, onFinally);}
const p = new MyPromise((resolve, reject) => {reject("error");// throw "error";
});
p.then((res) => {console.log("res:", res);
}).catch((error) => {console.log("err:", error);}).finally(() => {console.log("一定执行");});

静态方法

提供给promise静态的方法包括以下6个

reslove
reject
race
all
allsettled
any

reslove

Promise.resolve() 静态方法将给定的值转换为一个 Promise。如果该值本身就是一个 Promise，那么该 Promise 将被返回；如果该值是一个 thenable 对象，Promise.resolve() 将调用其 then() 方法及其两个回调函数；否则，返回的 Promise 将会以该值兑现

判断传入值
promise直接返回
转为promise并返回 fulfilled状态

thenable对象指的是具有then方法的对象。Promise.resolve方法会将这个对象转为Promise对象，然后立即执行thenable对象的then方法

 /*** 静态方法 resolve*  判断传入值*    promise直接返回*    转为promise并返回  fulfilled状态*/static resolve(value) {if (value instanceof MyPromise) {return value;}return new MyPromise((resolve, reject) => {resolve(value);});}// 测试代码// const p = MyPromise.resolve(
//   new MyPromise((resolve, reject) => {
//     resolve("ok");
//     // reject("error");
//     // throw "error";
//   })
// );
const p = MyPromise.resolve("贾公子");
p.then((res) => {console.log("res:", res);},(error) => {console.log("err:", error);}
);

reject

Promise.reject() 静态方法返回一个已拒绝（rejected）的 Promise 对象，拒绝原因为给定的参数。

 static reject(value) {return new MyPromise((resolve, reject) => {reject(value);});}
// 测试代码
const p = MyPromise.reject("贾公子");
p.then((res) => {console.log("res:", res);},(error) => {console.log("err:", error);}
);

`race`

Promise.race() 静态方法接受一个 promise 可迭代对象作为输入，并返回一个 promise 这个返回的 promise 会随着第一个 promise 的敲定而敲定。

接收一个promise数组返回的结果以第一个和promise返回的结果为准

* 返回promise

* 判断是否为数组(Array.isArray) 错误信息 Argument is not iterable

* 等待第一个敲定 (forEach取出每一个promise执行一旦执行就改变状态resolve包装一层因为有可能传递的不是promise)

  /*** 静态方法 race* 返回promise* 判断是否为数组 错误信息  Argument is not iterable* 等待第一个敲定*/static race(promises) {// 1.返回promisereturn new Promise((resolve, reject) => {// 2.判断是否为数组 错误信息  Argument is not iterableif (!Array.isArray(promises)) {return reject(new TypeError("Argument is not iterable"));}// 3.等待第一个敲定promises.forEach((p) => {MyPromise.resolve(p).then((res) => resolve(res),(err) => reject(err));});});}
}// 测试代码const p1 = new MyPromise((resolve, reject) => {setTimeout(() => {resolve("ok");}, 2000);
});
const p2 = new MyPromise((resolve, reject) => {setTimeout(() => {reject("err");}, 1000);
});
const p = MyPromise.race([p1, p2]);
// const p = MyPromise.race();
p.then((res) => {console.log("res:", res);},(error) => {console.log("err:", error);}
);

`all`

Promise.all() 静态方法接受一个 Promise 可迭代对象作为输入，并返回一个 Promise 。当所有输入的 Promise 都被兑现时，返回的 Promise 也将被兑现（即使传入的是一个空的可迭代对象），并返回一个包含所有兑现值的数组。如果输入的任何 Promise 被拒绝，则返回的 Promise 将被拒绝，并带有第一个被拒绝的原因。

1.返回promise
2.判断是否为数组错误信息 Argument is not iterable
3.空数组直接兑现
4.判断全部兑现
4.1记录结果(索引记录保证兑现顺序与传入顺序一样)
4.2判断全部兑现 (不能使用length 因为使用索引添加的可能导致没有全部兑现)
5.处理第一个拒绝

  static all(promises) {// 1.返回promisereturn new Promise((resolve, reject) => {// 2.判断是否为数组 错误信息  Argument is not iterableif (!Array.isArray(promises)) {return reject(new TypeError("Argument is not iterable"));}// 3.空数组直接兑现promises.length === 0 && resolve(promises);// 4.判断全部兑现const result = [];let count = 0;promises.forEach((p, index) => {MyPromise.resolve(p).then((res) => {// 4.1记录结果(索引记录保证兑现顺序与传入顺序一样)result[index] = res;// 4.2判断 全部兑现 (不能使用length 因为使用索引添加的可能导致没有全部兑现)count++;count === promises.length && resolve(result);},(err) => {// 5.处理第一个拒绝reject(err);});});});}// 测试代码
const p1 = MyPromise.resolve(1);
const p2 = new MyPromise((resolve, reject) => {setTimeout(() => {// resolve("ok");reject("err");}, 1000);
});
const p3 = "贾公子";
const p = MyPromise.all([p1, p2, p3]);
// const p = MyPromise.all();、
// const p = MyPromise.all([]);p.then((res) => {console.log("res:", res);},(error) => {console.log("err:", error);}
);

allSettled

Promise.allSettled() 静态方法将一个 Promise 可迭代对象作为输入，并返回一个单独的 promise。当所有输入的 Promise 都已敲定时（包括传入空的可迭代对象时），返回的 Promise 将被兑现，并带有描述每个 Promise 结果的对象数组。

* 1.传入的promise都已敲定,即可获取兑现结果

* 2.结果数组: [{status: 'fulfilled', value: 1},{status: 'rejected', reason: 'err'}]

* 3.结果数组的顺序,和传入的promise数组的顺序是一样的

* 4.空数组直接兑现

* 5.不为数组错误信息 Argument is not iterable

1.返回promise 可以让结果继续.then
2.数组判断不为数组直接抛出异常
3.为空直接敲定判断length
4.等待全部敲定使用forech 循环处理利用resolve包装一下
4.1记录结果(result) 记录敲定的次数(count）不使用push 会导致没有全部兑现
4.2 处理兑现{ status: FULFILLED, value: res }
4.3处理拒绝{ status: REJECTED, reason: err })
成功或者失败都是resolve

  static allSettled(promises) {// 1.返回promisereturn new Promise((resolve, reject) => {// 2.数组判断if (!Array.isArray(promises)) {return reject(new TypeError("Argument is not iterable"));}// 3.为空直接敲定promises.length === 0 && resolve(promises);// 4.等待全部敲定const result = [];let count = 0;promises.forEach((p, index) => {MyPromise.resolve(p).then((res) => {// 4.1记录结果result[index] = { status: FULFILLED, value: res }; // 4.2 处理兑现{ status: FULFILLED, value: res }// 记录敲定的次数count++;// 不论成功失败都是resolvecount === promises.length && resolve(result);},(err) => {// 4.1记录结果result[index] = { status: REJECTED, reason: err }; // 4.3处理拒绝{ status: REJECTED, reason: err }// 记录敲定的次数count++;// 不论成功失败都是resolvecount === promises.length && resolve(result);});});});}
// 测试代码
const p1 = MyPromise.resolve(1);
const p2 = new MyPromise((resolve, reject) => {setTimeout(() => {// resolve("ok");reject("err");}, 1000);
});
const p3 = "贾公子";
const p = MyPromise.allSettled([p1, p2, p3]);
// const p = MyPromise.allSettled();
// const p = MyPromise.allSettled([]);p.then((res) => {console.log("res:", res);},(error) => {console.log("err:", error);}
);

any

Promise.any() 静态方法将一个 Promise 可迭代对象作为输入，并返回一个 promise 当输入的任何一个 Promise 兑现时，这个返回的 Promise 将会兑现，并返回第一个兑现的值。当所有输入 Promise 都被拒绝（包括传递了空的可迭代对象）时，它会以一个包含拒绝原因数组的 AggregateErrorAggregateErrorAggregateError 拒绝。

AggregateError 对象代表了包装了多个错误对象的单个错误对象。当一个操作需要报告多个错误时，例如 promise.any，当传递给它的所有承诺都被拒绝时，就会抛出该错误。

* 参数：promise数组

* 结果

* 获取到第一个成功的结果

* 获取到所有拒绝失败的原因 AggregateError: All promises were rejected[拒绝原因1，拒绝原因n]

* 传入空数组，直接拒绝 AggregateError: All promises were rejected[]

* 不传入数组直接报错

1.返回promise
2.数组判断错误信息 Argument is not iterable
3.空数组直接拒绝 AggregateError([错误原因]，All promises were rejected[)
4.等待结果
4.1第一个兑现
4.2全部拒绝

  static any(promises) {// 1.返回promisereturn new Promise((resolve, reject) => {// 2.数组判断 错误信息 Argument is not iterableif (!Array.isArray(promises)) {return reject(new TypeError("Argument is not iterable"));}// 3.空数组直接拒绝 AggregateError([错误原因]，All promises were rejected[)promises.length === 0 &&reject(new AggregateError(promises, "All promises were rejected"));const errors = [];let count = 0;// 4.等待结果promises.forEach((p, index) => {MyPromise.resolve(p).then((res) => {// 4.1第一个兑现resolve(res);},(err) => {// 4.2全部拒绝errors[index] = err;count++;count === promises.length &&reject(new AggregateError(errors, "All promises were rejected"));});});});}
// 测试代码
const p1 = new MyPromise((resolve, reject) => {setTimeout(() => {// resolve("ok");reject("err1");}, 1000);
});
const p2 = new MyPromise((resolve, reject) => {setTimeout(() => {// resolve("ok");reject("err2");}, 2000);
});
// const p3 = "贾公子";
const p3 = MyPromise.reject("贾公子");const p = MyPromise.any([p1, p2, p3]);
// const p = MyPromise.any();
// const p = MyPromise.any([]);p.then((res) => {console.log("res:", res);},(error) => {// console.log("err:", error);console.dir(error);}
);