Promise相关

promise函数介绍

1、promise 和 async/awite关系

async/awite自身就是一个promise函数

test(code = false) {
      return new Promise((resolve, reject) => {
        if (code) {
          setTimeout(() => {
            resolve("success");
          }, 2000);
        } else {
          setTimeout(() => {
            reject("失败");
          }, 2000);
        }
      });
    },

    async test1() {
      try {
        const res = await this.test();
        return res;
      } catch (error) {
        return Promise.reject(error);
      }
    },

    async test2() {
      // 第一种写法
      try {
        const res = await this.test1();
      } catch (error) {
        console.error(error);
        // return Promise.reject(error);
      }
      // 第二种写法
      this.test1()
        .then(res => {
          console.log(res);
        })
        .catch(error => {
          console.error(error);
          // return Promise.reject(error);
        });
    }

    test(code = false) {
      return new Promise((resolve, reject) => {
        if (code) {
          setTimeout(() => {
            resolve("success");
          }, 2000);
        } else {
          setTimeout(() => {
            reject("失败");
          }, 2000);
        }
      });
    },

    test1() {
      return new Promise((resolve, reject) => {
        this.test()
          .then(res => {
            console.log(res, "test1");
            resolve();
          })
          .catch(error => {
            console.error(error, "test1");
            reject(error);
          });
      });
    },

    test2() {
      this.test1()
        .then(res => {
          console.log(res, "test2-res");
        })
        .catch(error => {
          console.error(error, "test2-error");
        });
    }

2、Promise.all()

1. 如果所有 promise 都成功解析，Promise.all() 会将每个 promise 的已完成值 聚合 到数组。我们可以按照原来参数中每一个promise的顺序，获取到他们对应的完成值。
2. 如果有其中一个 promise 被拒绝，那么 Promise.all() 会以同样的原因立即拒绝（不等待其他 Promise 解决）
3. 特点： 1、并行 2、聚合结果 3、快速失败 注意：Promise.all() 里面的子项都必为promise(async/awite),非promise无法返回结果抛出去

    test1(code = true) {
      return new Promise((resolve, reject) => {
        if (code) {
          setTimeout(() => {
            resolve("res1");
          }, 1000);
        } else {
          setTimeout(() => {
            reject("error1");
          }, 1000);
        }
      });
    },

    test2(code = false) {
      return new Promise((resolve, reject) => {
        if (code) {
          setTimeout(() => {
            resolve("res2");
          }, 1000);
        } else {
          setTimeout(() => {
            reject("error2");
          }, 1000);
        }
      });
    },

    test() {
      Promise.all([this.test1(), this.test2()])
        .then(res => {
          console.log(res, "all");
        })
        .catch(err => {
          console.error(err, "all");
        });
    }

3、Promise.allSettled()

1、Promise.allSettled永远不会被reject (即没有catch可用于捕获，将所有子项的结果汇总在一起，无论成功或者失败）

const promises = [
  delay(100).then(() => 1),
  delay(200).then(() => 2),
  Promise.reject(3)
  ]

Promise.allSettled(promises).then(values=>console.log(values))
// 最终输出： 
//    [
//      {status: "fulfilled", value: 1},
//      {status: "fulfilled", value: 2},
//      {status: "rejected", value: 3},
//    ]

4、Promise.race() / Promise.any()

1、race : 一个待定的 Promise 只要给定的迭代中的一个promise解决或拒绝，就采用第一个promise的值（无论成功或者失败）作为它的值，从而异步地解析或拒绝;

2、any: Promise.any()  接收一个Promise可迭代对象，只要其中的一个 promise 成功，就返回那个已经成功的 promise 。如果可迭代对象中没有一个 promise 成功（即所有的 promises 都失败/拒绝），就返回一个失败的 promise 和AggregateError类型的实例，它是 Error 的一个子类，用于把单一的错误集合在一起。本质上，这个方法和Promise.all()是相反的。

3、写法都可以参照promise.all()

5、（手写？）