介绍一下Promise

Promise 是 JavaScript 中用于处理异步操作的对象。它表示一个异步操作的最终完成（或失败）及其结果值。Promise 提供了一种更优雅的方式来处理异步代码，避免了传统的回调地狱（Callback Hell）。

Promise 的三种状态

1. Pending（等待）：初始状态，既不是成功，也不是失败。

2. Fulfilled（已成功）：操作成功完成。

3. Rejected（已失败）：操作失败。

创建 Promise

const myPromise = new Promise((resolve, reject) => {
    // 异步操作
    setTimeout(() => {
        const success = true; // 模拟操作成功或失败
        if (success) {
            resolve('Operation succeeded!');
        } else {
            reject('Operation failed!');
        }
    }, 1000);
});

使用 Promise

then 方法

then 方法用于处理 Promise 的成功状态。

myPromise.then((result) => {
    console.log(result); // 输出: Operation succeeded!
});

catch 方法

catch 方法用于处理 Promise 的失败状态。

myPromise.catch((error) => {
    console.error(error); // 输出: Operation failed!
});

finally 方法

finally 方法无论 Promise 成功或失败都会执行。

myPromise.finally(() => {
    console.log('Operation completed!');
});

链式调用

Promise 支持链式调用，使得多个异步操作可以顺序执行。

myPromise
    .then((result) => {
        console.log(result); // 输出: Operation succeeded!
        return 'Next step';
    })
    .then((nextResult) => {
        console.log(nextResult); // 输出: Next step
    })
    .catch((error) => {
        console.error(error); // 输出: Operation failed!
    })
    .finally(() => {
        console.log('Operation completed!');
    });

Promise 的静态方法

Promise.resolve

创建一个立即成功的 Promise。

const resolvedPromise = Promise.resolve('Resolved immediately');
resolvedPromise.then((result) => {
    console.log(result); // 输出: Resolved immediately
});

Promise.reject

创建一个立即失败的 Promise。

const rejectedPromise = Promise.reject('Rejected immediately');
rejectedPromise.catch((error) => {
    console.error(error); // 输出: Rejected immediately
});

Promise.all

等待所有 Promise 完成，或任何一个 Promise 失败。

const promise1 = Promise.resolve('First');
const promise2 = Promise.resolve('Second');
const promise3 = Promise.resolve('Third');

Promise.all([promise1, promise2, promise3])
    .then((results) => {
        console.log(results); // 输出: ['First', 'Second', 'Third']
    })
    .catch((error) => {
        console.error(error);
    });

Promise.race

返回第一个完成（成功或失败）的 Promise 的结果。

const promise1 = new Promise((resolve) => setTimeout(resolve, 500, 'First'));
const promise2 = new Promise((resolve) => setTimeout(resolve, 100, 'Second'));

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

总结

• Promise 是处理异步操作的对象，具有三种状态：Pending、Fulfilled 和 Rejected。

• 使用 then、catch 和 finally 方法来处理 Promise 的结果。

• 支持链式调用，使得多个异步操作可以顺序执行。

• 提供静态方法如 Promise.resolve、Promise.reject、Promise.all 和 Promise.race 来处理多个 Promise。

Promise 提供了一种更优雅和可读性更高的方式来处理异步操作，是现代 JavaScript 开发中的重要工具。