跳到主要内容

方法

Promise.prototype.then​

Promise.prototype.then 分别指定resolved状态和rejected状态的回调函数。Promise.prototype.then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用。这两个函数都是可选的，不一定要提供。

语法

Promise.prototype.then(onResolved, onRejected);

  • onResolved: 成功的回调函数 (value) =>

  • onRejected: 失败的回调函数 (reason) =>

返回值

返回一个新的 promise 对象

Promise.prototype.catch​

then()的语法糖, 相当于: then(undefined, onRejected)

语法

Promise.prototype.catch(onRejected);
  • onRejected: 失败的回调函数 (reason) =>

返回值

返回一个新的 promise 对象

Promise.prototype.finally​

Promise.prototype.finally 用于指定 Promise 对象变更状态之后执行的操作。无论是 Promise 最后的状态变为 fulfilled 还是 rejected。

语法

new Promise((resolve) => {
  resolve();
})
  .then(() => {
    console.log(1);
  })
  .catch((error) => {
    console.log("error", error);
  })
  .finally(() => {
    console.log(2);
  });

返回值

返回一个新的 Promise 对象

Promise.all​

Promise.all 方法用于将多个 Promise 实例（如果某一个元素不是 Promise 实例, 会调用 Promise.resolve 将该元素转化为 Promise 实例。 ），包装成一个新的 Promise 实例。 新的 Promise 实例的状态由传入的多个 Promise 实例的状态 决定。分两种情况:

  • 传入的多个Promise实例状态都变为 Fulfilled: 新的 Promise 实例的状态变为 Fulfilled。此时, 多个Promise实例的返回值组成一个数组,传递给新的 Promise 实例的回调函数

  • 传入的多个Promise实例状态只要有一个变为 Rejected: 新的 Promise 实例的状态变为 Reject, 此时第一个被Reject的实例的返回值，会传递给新的 Promise 实例的回调函数。

语法

Promise.all([promise1,promise2,……]);
  • promises: 包含 n 个 promise 的数组。如果某一个元素不是 Promise 实例, 会调用 Promise.resolve 将该元素转化为 Promise 实例。 ），包装成一个新的 Promise 实例。

用法

  • 用法一、[number,new Promise((resolve)=>{ resolve() }).then()]

    const promise2 = new Promise((resolve) => {
        resolve(2);
    });

    Promise.all([1, promise2]).then((res) => {
        console.log(res); // [ 1, 2 ]
    });

  • 用法二、[number,new Promise((resolve,reject)=>{ reject() }).then()]

    Promise.all([1, promise2])
    .then((res) => {
        console.log(res);
    })
    .catch((error) => {
        console.log("promise.all", error); // promise.all 2
    });

  • 用法三、[number,new Promise((resolve,reject)=>{ reject() }).then().catch()]: 如果作为参数的 Promise 实例，自己定义了catch方法，那么它一旦被rejected，并不会触发Promise.all()的catch方法。作为参数的 Promise 实例执行完自己定义的 catch 方法之后, 会变为 Fulfilled 状态。

    const promise2 = new Promise((resolve, reject) => {
        reject(2);
    }).catch((error) => {
        console.log("promise catch", error); // promise catch 2
        return 2;
    });

    Promise.all([1, promise2])
    .then((res) => {
        console.log(res); // [ 1, 2 ]
    })
    .catch((error) => {
        console.log("promise.all", error);
    });

返回值

返回一个新的 promise

应用场景

Promise.any​

Promise.any 方法用于将多个 Promise 实例（如果某一个元素不是 Promise 实例, 会调用 Promise.resolve 将该元素转化为 Promise 实例。 ），包装成一个新的 Promise 实例。 只要参数实例有一个变成fulfilled状态，包装实例就会变成fulfilled状态；如果所有参数实例都变成rejected状态，包装实例就会变成rejected状态。抛出的错误是一个 AggregateError 实例, 这个 AggregateError 实例对象的errors属性是一个数组，包含了所有成员的错误。

语法

Promise.any([promise1,promise2,……]);
  • promises: 包含 n 个 promise 的数组

用法

  • 用法一、new Promise((resolve,reject)=>{ reject() }, new Promise((resolve,reject)=>{ reject() })

    const promise1 = new Promise((resolv, reject) => {
        setTimeout(() => {
            reject(1);
        }, 3000);
    });

    const promise2 = new Promise((resolve, reject) => {
        setTimeout(() => {
            reject(1);
        }, 5000);
    });

    Promise.any([promise1, promise2])
    .then((res) => {
        console.log(res);
    })
    .catch((error) => {
        console.log("error", error); // error [AggregateError: All promises were rejected] { [errors]: [ 1, 1 ] }
    });

  • 用法二、new Promise((resolve)=>{ resolve() }, new Promise((resolve,reject)=>{ reject() }), number, number

    const promise1 = new Promise((resolve) => {
        setTimeout(() => {
            resolve(1);
        }, 3000);
    });

    const promise2 = new Promise((resolve, reject) => {
        setTimeout(() => {
            reject(1);
        }, 5000);
    });

    Promise.any([promise1, promise2, 3, 4])
    .then((res) => {
        console.log(res);
    })
    .catch((error) => {
        console.log("error", error);
    });

返回值

返回一个新的 promise

Promise.race​

Promise.race 方法用于将多个 Promise 实例（如果某一个元素不是 Promise 实例, 会调用 Promise.resolve 将该元素转化为 Promise 实例。 ），包装成一个新的 Promise 实例。 新的 Promise 实例的状态同多个 Promise 实例中率先改变的 Promise 实例状态一致。那个率先改变的 Promise 实例的返回值，就传递给的新的 Promise 实例的回调函数。

语法

Promise.race([promise1,promise2,……]);
  • promises: 包含 n 个 promise 的数组。如果某一个元素不是 Promise 实例, 会调用 Promise.resolve 将该元素转化为 Promise 实例。 ），包装成一个新的 Promise 实例。

返回值

返回一个新的 promise

应用场景

  • 场景一、指定时间内如果没有结果, 将结果变为 reject， 否则变为 resolve

    const promise1 = new Promise((resolve) => {
        setTimeout(() => {
            resolve(1);
        }, 3000);
    });

    Promise.race([
        promise1,
        new Promise((resolve, reject) => {
            setTimeout(() => {
            reject(2);
            }, 2000);
        }),
    ])
    .then((res) => {
        console.log(res);
    })
    .catch((error) => {
        console.log("promise.race", error);
    });

Promise.reject​

Promise.reject 将现有对象转为 Promise 对象, 该实例的状态为rejected。Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。所以, Promise.reject 并不像 Promise.resolve 那样复杂。

语法

Promise.reject((reason) => {} );
  • reason: 失败的原因。 reason 会原封不动地作为reject的理由，变成后续方法的参数。

返回值

返回一个失败的 promise 对象

Promise.resolve​

Promise.resolve 将现有对象转为 Promise 对象

语法

Promise.resolve(value);

  • value: 分成四种情况

    • value 为空: 直接返回一个resolved状态的 Promise 对象。

    • value 为 普通数据: 返回一个新的 Promise 对象，状态为resolved。

    • value 为 Promise 实例: 那么Promise.resolve将不做任何修改、原封不动地返回这个实例。

    • value 为 thenable 对象: Promise.resolve()方法会将这个对象转为 Promise 对象，然后就立即执行 thenable对象的then()方法。

用法

  • 用法一、value 为空: 直接返回一个resolved状态的 Promise 对象。所以，如果希望得到一个 Promise 对象，比较方便的方法就是直接调用Promise.resolve()方法。

    const promise = Promise.resolve();

    promise.then(() => {
        console.log("value 为空");
    });

    等价于

    const promise = new Promise((resolve) => {
        resolve();
    });

    promise.then(() => {
        console.log("value 为空");
    });

  • 用法二、value 普通数据: 返回一个新的 Promise 对象，状态为resolved。

    const promise = Promise.resolve(1);

    promise.then((res) => {
        console.log(res);
    });

    等价于

    const promise = new Promise((resolve) => {
        resolve(1);
    });

    promise.then((res) => {
        console.log(res);
    });

  • 用法三、value 为 Promise 实例: 那么Promise.resolve将不做任何修改、原封不动地返回这个实例。

    Promise.resolve(new Promise((resolve,reject)=> {resolve()}))

    const promise = Promise.resolve(
        new Promise((resolve, reject) => {
            resolve(1);
        })
    );

    promise.then((res) => {
        console.log(res);
    });

    Promise.resolve(new Promise((resolve,reject)=> {reject()}))

    const promise = Promise.resolve(
        new Promise((resolve, reject) => {
            reject(1);
        })
    );

    promise
    .then((res) => {
        console.log(res);
    })
    .catch((error) => {
        console.log("error", error);
    });

  • 用法四、value 为 thenable 实例: Promise.resolve()方法会将这个对象转为 Promise 对象，然后就立即执行 thenable对象的then()方法。

    Promise.resolve({ then: (resolve)=>{ resolve() } })

    const thenable = {
        then(resolve, reject) {
            resolve(1);
        },
    };

    const promise = Promise.resolve(thenable);

    promise
    .then((res) => {
        console.log(res);
    })
    .catch((error) => {
        console.log("error", error);
    });

    Promise.resolve({ then: (resolve,reject)=>{ reject() } })

    const thenable = {
        then(resolve, reject) {
            reject(1);
        },
    };

    const promise = Promise.resolve(thenable);

    promise
    .then((res) => {
        console.log(res);
    })
    .catch((error) => {
        console.log("error", error);
    });

返回值

返回一个成功/失败的 promise 对象

Promise.allSettled​

Promise.allSettled 用来确定一组异步操作是否都结束了（不管成功或失败）。所以，它的名字叫做Settled，包含了fulfilled和rejected两种情况。接受一个数组作为参数，数组的每个成员都是一个 Promise 对象，并返回一个新的 Promise 对象。只有等到参数数组的所有 Promise 对象都发生状态变更（不管是fulfilled还是rejected），返回的 Promise 对象才会发生状态变更。并且, Promise.allSettled 只有 penging -> fulfilled 的状态变化。状态只可能变成fulfilled。

语法

Promise.allSettled([promise1,promise2,……]);
  • promises: 包含 n 个 promise 的数组

用法

  • 用法一、new Promise((resolve)=>{ resolve() }, new Promise((resolve,reject)=>{ reject() }), number, number

    const promise1 = new Promise((resolve) => {
        setTimeout(() => {
            resolve(1);
        }, 3000);
    });

    const promise2 = new Promise((resolve, reject) => {
        setTimeout(() => {
            reject(1);
        }, 5000);
    });

    Promise.allSettled([promise1, promise2, 3, 4]).then((res) => {
        console.log(res);
        /**
        * @description: 返回值
        *[
                { status: 'fulfilled', value: 1 },
                { status: 'rejected', reason: 1 },
                { status: 'fulfilled', value: 3 },
                { status: 'fulfilled', value: 4 }
            ]
        */
    });

返回值

Promise.allSettled 返回值是 allSettledPromise。格式为:

[
    // 异步操作成功时
    {status: 'fulfilled', value: value},
    // 异步操作失败时
    {status: 'rejected', reason: reason}
]