promise类方法

Promise 类在 JavaScript 中提供了一些静态方法和实例方法，用于处理异步操作。以下是 Promise 类的主要方法：

1. 静态方法

Promise.all(iterable)

• 描述: 接受一个可迭代对象（如数组），返回一个新的 Promise，该 Promise 在所有输入的 Promise 都成功时解决，或者在任何一个输入的 Promise 失败时拒绝。
• 用法:

const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(resolve, 100, "foo"));
const promise3 = 42;

Promise.all([promise1, promise2, promise3])
    .then(values => {
        console.log(values); // 输出: [3, "foo", 42]
    })
    .catch(error => {
        console.error(error);
    });

Promise.allSettled(iterable)

• 描述: 接受一个可迭代对象，返回一个新的 Promise，该 Promise 在所有输入的 Promise 都已完成（无论成功或失败）时解决，返回一个对象数组，描述每个 Promise 的结果。
• 用法:

const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, "foo"));
const promise3 = 42;

Promise.allSettled([promise1, promise2, promise3])
    .then(results => {
        console.log(results);
        // 输出: 
        // [
        //   { status: "fulfilled", value: 3 },
        //   { status: "rejected", reason: "foo" },
        //   { status: "fulfilled", value: 42 }
        // ]
    });

Promise.any(iterable)

• 描述: 接受一个可迭代对象，返回一个新的 Promise，该 Promise 在第一个成功的 Promise 解决时解决，或者在所有输入的 Promise 都失败时拒绝。
• 用法:

const promise1 = Promise.reject("error1");
const promise2 = Promise.reject("error2");
const promise3 = Promise.resolve("success");

Promise.any([promise1, promise2, promise3])
    .then(value => {
        console.log(value); // 输出: "success"
    })
    .catch(error => {
        console.error(error);
    });

Promise.race(iterable)

• 描述: 接受一个可迭代对象，返回一个新的 Promise，该 Promise 在第一个解决或拒绝的 Promise 解决时解决或拒绝。
• 用法:

const promise1 = new Promise((resolve, reject) => setTimeout(resolve, 100, "one"));
const promise2 = new Promise((resolve, reject) => setTimeout(resolve, 200, "two"));

Promise.race([promise1, promise2])
    .then(value => {
        console.log(value); // 输出: "one"
    });

2. 实例方法

promise.then(onFulfilled, onRejected)

• 描述: 添加成功和失败的回调函数，返回一个新的 Promise。
• 用法:

const promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve("成功"), 1000);
});

promise.then(result => {
    console.log(result); // 输出: "成功"
}).catch(error => {
    console.error(error);
});

promise.catch(onRejected)

• 描述: 添加一个失败的回调函数，返回一个新的 Promise。
• 用法:

const promise = new Promise((resolve, reject) => {
    setTimeout(() => reject("失败"), 1000);
});

promise.catch(error => {
    console.error(error); // 输出: "失败"
});

promise.finally(onFinally)

• 描述: 添加一个最终的回调函数，无论 Promise 是成功还是失败，都会执行该回调。返回一个新的 Promise。
• 用法:

const promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve("成功"), 1000);
});

promise
    .then(result => {
        console.log(result); // 输出: "成功"
    })
    .catch(error => {
        console.error(error);
    })
    .finally(() => {
        console.log("无论成功还是失败，这里都会执行"); // 输出: "无论成功还是失败，这里都会执行"
    });

总结

Promise 类提供了多种方法来处理异步操作，使得代码更加清晰和易于维护。通过使用这些方法，可以方便地管理多个异步操作的结果和错误处理。希望这些信息能帮助你更好地理解和使用 Promise！如果你有其他问题，请随时问我。