promise总结

//所有的promise都成功
const a = [
    new Promise((resolve, reject) => { resolve("resolve:1") }),
    new Promise((resolve, reject) => { resolve("resolve:2") }),
    new Promise((resolve, reject) => { resolve("resolve:3") })
]
//有一个promise失败，其他成功
const b = [
    new Promise((resolve, reject) => { reject("reject:1") }),
    new Promise((resolve, reject) => { resolve("resolve:2") }),
    new Promise((resolve, reject) => { resolve("resolve:3") })
]
//所有的promise都失败
const c = [
    new Promise((resolve, reject) => { reject("reject:1") }),
    new Promise((resolve, reject) => { reject("reject:2") }),
    new Promise((resolve, reject) => { reject("reject:3") })
]


// promise.all中所有的请求成功了，走.then()，在.then()中能得到一个数组，数组中是每个请求resolve抛出的结果。
// promise.all中只要有一个失败了，走.catch()，在.catch()中获取第一个失败请求rejected抛出的结果。
// 在 Promise.all 中，如果其中任何一个 Promise 被 rejected 或抛出异常，则整个 Promise.all 将会立即被 reject，而不会等到其他 Promise 完成。
Promise.all(a).then(([p1, p2, p3]) => { console.log(p1, p2, p3) }).catch(err => { console.log(err) })
Promise.all(b).then(([p1, p2, p3]) => { console.log(p1, p2, p3) }).catch(err => { console.log(err) })
Promise.all(c).then(([p1, p2, p3]) => { console.log(p1, p2, p3) }).catch(err => { console.log(err) })
//结果：
//resolve:1 resolve:2 resolve:3
//reject:1
//reject:1


// Promise.any，它也是接受一个promise数组，只要有一个成功，就会执行.then()，返回的是第一个成功的请求resolve抛出的结果
// 只有当所有的promise都失败，才算失败，此时Promise.any 会把所有的失败/错误集合在一起，
// 返回一个失败的 promise 和AggregateError类型的实例。
Promise.any(a).then((res) => { console.log(res) }).catch(err => { console.log(err) })
Promise.any(b).then((res) => { console.log(res) }).catch(err => { console.log(err) })
Promise.any(c).then((res) => { console.log(res) }).catch(err => {
    console.log('所有 Promise 都被拒绝:', err);
    console.log('具体错误:', err.errors);
})
//结果：
//resolve:1 
//resolve:2
//所有 Promise 都被拒绝: AggregateError: All promises were rejected
//具体错误: (3) ['reject:1', 'reject:2', 'reject:3']

// Promise.allSettled，它同样是接受一个 Promise数组，但它不会执行.catch，只会执行.then，也是等所有请求结束后，返回一个数组，数组里的每项与参数的数组每项一一对应，
// 返回的每项包含字段：status：状态（rejected/fulfilled），value：成功返回的值，reason：失败返回的值。
Promise.allSettled(a).then(([p1, p2, p3]) => { console.log(p1, p2, p3) }).catch(err => { console.log(err) })
Promise.allSettled(b).then(([p1, p2, p3]) => { console.log(p1, p2, p3) }).catch(err => { console.log(err) })
Promise.allSettled(c).then(([p1, p2, p3]) => { console.log(p1, p2, p3) }).catch(err => { console.log(err) })

//结果：
//{status: "fulfilled", value: "resolve:1"} {status: "fulfilled", value: "resolve:2"} {status: "fulfilled", value: "resolve:3"}
//{status: "rejected", reason: "reject:1"} {status: "fulfilled", value: "resolve:2"} {status: "fulfilled", value: "resolve:3"}
//{status: "rejected", reason: "reject:1"} {status: "rejected", reason: "reject:2"} {status: "rejected", reason: "reject:3"}

const p1 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("resolve:1")
    }, 3000)
})
const p2 = new Promise((resolve, reject) => {
    setTimeout(() => {
        reject("reject:2")
    }, 1000)
})
const p3 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("resolve:3")
    }, 2000)
})
// Promise.race，它也是接受一个promise数组，promise哪个返回的结果最快,就返回哪个，成功就.then(),失败就.catch()


Promise.race([p1, p2, p3]).then((res) => { console.log(res) }).catch(err => { console.log(err) })


//结果：reject: 2




// Promise有pending, fulfilled, rejected三种状态，
// 其决议函数resolve()能将Promise实例的状态由pending转为fulfilled，
// 其决议函数reject()能将Promise实例的状态由pending转为rejected。
// Promise实例的状态一旦转变，不可再逆转。

//.then, .catch, .finally都产生一个新的Promise实例，
//async 方法也是一个promise。

//如何理解then中抛出异常后会触发随后的catch
// 由于.then会返回一个新的Promise实例，而在.then回调中抛出了异常，导致这个新Promise的状态变成了rejected，
// 而.catch正是用于处理这个新的Promise实例的rejected场景的。


var promise = new Promise(function (resolve, reject) {
    //To Do 要异步执行的事情，这个异步执行的事情有可能成功执行完毕，那么Promise将是fulfilled状态，如果执行失败则是rejected;
    //下面测试代码，人为设置为rejected状态;
    reject("将当前构建的Promise对象的状态由pending（进行中）设置为rejected（已拒绝）"); //当然此处也可以设置为fulfilled(已完成)状态
})

promise.then(//调用第一个then()
    success => {
        console.log("异步执行成功，状态为：fulfilled，成功后返回的结果是：" + success);
        return (" 当前 success ");
    },
    error => {
        console.log("异步执行失败，状态为rejected，失败后返回的结果是：" + error);
        return (" 当前 error ");
    }
).then(
    //调用第二个then() 因为调用第一个then()方法返回的是一个新的promise对象，此对象的状态由上面的success或者error两个回调函数的执行情况决定的：
    //如果回调函数能正常执行完毕，则新的promise对象的状态为fulfilled，下面执行success2,如果回调函数无法正常执行，则promise状态为rejected;下面执行error2
    success2 => {
        console.log("第一个then的回调函数执行成功 成功返回结果：" + success2);
        throw (" 当前 success2 ");//自定义异常抛出
    },
    error2 => {
        console.log("第一个then的回调函数执行失败 失败返回结果：" + error2);
        return (" 当前 error2 ");
    }
).catch(err => {
    //当success2或者error2执行报错时，catch会捕获异常;
    console.log("捕获异常：" + err);
});

//上述代码,打印如下:
//异步执行失败，状态为rejected，失败后返回的结果是：将当前构建的Promise对象的状态由pending（进行中）设置为rejected（已拒绝）
//第一个then的回调函数执行成功 成功返回结果： 当前 error
//捕获异常： 当前 success2

参考链接: https://www.cnblogs.com/grow-up-up/p/17000726.html