Promise

function requestData(url, successCallback, failtureCallback) {
  // 异步操作：网络请求
  setTimeout(() => {
    if (url === "sun") {
      // 请求成功
      const res = ["sun", "james", "lebron"];
      successCallback(res);
    } else {
      // 请求失败
      const error = "路径错误";
      failtureCallback(error);
    }
  }, 3000);
}

requestData(
  "sn",
  function (res) {
    console.log(res);
  },
  function (error) {
    console.log(error);
  }
);回调函数的痛点：

function requestData(url) {
  // 异步操作：网络请求
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (url === "sun") {
        // 请求成功
        const res = ["sun", "james", "lebron"];
        resolve(res);
      } else {
        // 请求失败
        const error = "路径错误";
        reject(error);
      }
    }, 3000);
  });
}

requestData("sun")
  .then((res) => {
    console.log(res); //[ "sun", "james", "lebron" ]
  })
  .catch((error) => {
    console.log(error); //路径错误
  });Promise的代码结构Promise使用过程，可以将它划分成三个状态：

const newPromise = new Promise((resolve, reject) => {
  resolve("传入的是一个promise对象");
});
const obj = {
  then: function (resolve, reject) {
    resolve("传入的是一个具有then方法的对象");
  },
};
new Promise((resolve, reject) => {
  // resolve("成功"),
  // resolve(newPromise);
  resolve(obj);
  reject("拒绝");
}).then(
  (res) => {
    // console.log(res); //"成功"
    // console.log(res); //"传入的是一个promise对象"
    console.log(res); //"传入的是一个具有then方法的对象"
  },
  (err) => {
    console.log(err);
  }
);then方法then方法接受两个参数：

const promise = new Promise((resolve, reject) => {
  resolve("aaa");
});
promise.then((res) => {
  console.log("res1", res);
});
promise.then((res) => {
  console.log("res2", res);
});
// res1 aaa
// res2 aaathen方法的返回值：
then方法的返回值也是一个Promise对象，所以可以对promise进行链式调用。then方法返回的Promise也有三种状态：

const promise = new Promise((resolve, reject) => {
  resolve("aaa");
});

promise
  .then((res) => {
    return "sun";
    // return "sun" 相当于return一个新的promise,并把执行resolve("sun")
    // return new Promise((resolve, reject) => {
    //   resolve("sun");
    // });
  })
  .then((res) => {
    console.log(res);
  });catch方法一个Promise的catch方法是可以被多次调用的：每次调用我们都可以传入对应的reject回调；当Promise的状态变成reject或者executor中发生异常的时候，这些回调函数都会被执行；
在执行promise的then方法时传入的第二个回调函数会在executor中reject函数执行的时候触发。但是当链式调用的时候then方法需要传入两个回调函数会造成阅读性较差。所以就可以通过catch方法进行捕获。

const promise = new Promise((resolve, reject) => {
  resolve("sun");
  // reject("aaa");
  // throw new Error("有异常");
});

promise
  .then((res) => {
    console.log(res);
  })
  .catch((err) => {
    console.log("err1", err);
  });需要注意的是，catch可以看作是一个es6语法糖，它是先捕获promise中的异常再捕获then中返回的new Promise对象的异常。

const promise = new Promise((resolve, reject) => {
  resolve("sun");
  // reject("aaa");
  // throw new Error("有异常");
});

promise
  .then((res) => {
    console.log(res);
  })
  .catch((err) => {
    console.log("err1", err);
  })
  .finally(() => {
    console.log("finally方法执行");
  });Promise类方法：resolve前面的then、catch、finally方法都属于Promise的实例方法，都是存放在Promise的prototype上的。
以下是Promise的一些类方法。
场景：有时候我们已经有一个现成的内容了，希望将其转成Promise来使用，这个时候我们可以使用 Promise.resolve 方法来完成。Promise.resolve的用法相当于new Promise，并且执行resolve操作。

const obj = {
  name: "sun",
};
function foo(obj) {
  return new Promise((resolve, reject) => {
    resolve(obj);
  });
}
foo(obj).then((res) => {
  console.log(res); //{ name: "sun" }
});

// 使用Promise.resolve
Promise.resolve(obj).then((res) => {
  console.log(res); //{ name: "sun" }
});Promise类方法：all它的作用是将多个Promise包裹在一起形成一个新的Promise；
新的Promise状态由包裹的所有Promise共同决定：

const p1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("p1");
  }, 1000);
});
const p2 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("p2");
  }, 2000);
});
const p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("p3");
  }, 3000);
});

Promise.all([p1, p2, p3, "aaa"]).then((res) => {
  console.log(res); //[ "p1","p2", "p3", "aaa" ]
});Promise类方法：allSettledall方法有一个缺陷：当有其中一个Promise变成reject状态时，新Promise就会立即变成对应的reject状态。那么对于resolved的，以及依然处于pending状态的Promise，是获取不到对应的结果的；

const p1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("p1");
  }, 1000);
});
const p2 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("p2");
  }, 2000);
});
const p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    reject("p3");
  }, 3000);
});

Promise.all([p1, p2, p3, "aaa"])
  .then((res) => {
    console.log(res);
  })
  .catch((err) => {
    console.log(err); //p3
  });

Promise.allSettled([p1, p2, p3, "aaa"]).then((res) => {
  console.log(res);
});
// [
//   { status: "fulfilled", value: "p1" },
//   { status: "fulfilled", value: "p2" },
//   { status: "rejected", reason: "p3" },
//   { status: "fulfilled", value: "aaa" }
// ]Promise类方法：race如果有一个Promise有了结果，就希望决定最终新Promise的状态，那么可以使用race方法：race是竞技、竞赛的意思，表示多个Promise相互竞争，谁先有结果，那么就使用谁的结果；