什么是promise？

在 JavaScript 中，Promise 是一个用于处理异步操作的对象，它代表了一个最终会完成（或失败）的异步操作及其结果。Promise 提供了一种更清晰和灵活的方式来处理异步代码，相比传统的回调函数（即“回调地狱”），Promise 更容易管理和阅读。

基本概念

1. 状态：

   • Pending（进行中）：初始状态，既不是成功也不是失败。
   • Fulfilled（已成功）：操作成功完成。
   • Rejected（已失败）：操作失败。

2. 方法：

   • then(onFulfilled, onRejected)：用于注册成功和失败的回调函数。
   • catch(onRejected)：用于捕获错误，等同于 then(null, onRejected)。
   • finally(onFinally)：无论成功还是失败都会执行的回调函数。

创建 Promise

你可以使用 new Promise 构造函数来创建一个新的 Promise 对象。构造函数接受一个执行器函数（executor function），该函数有两个参数：resolve 和 reject。

const myPromise = new Promise((resolve, reject) => {
    // 模拟异步操作
    setTimeout(() => {
        const success = true; // 假设操作成功
        if (success) {
            resolve("Operation successful");
        } else {
            reject("Operation failed");
        }
    }, 1000);
});

使用 Promise

then 方法

then 方法用于注册成功和失败的回调函数。它可以链式调用，返回一个新的 Promise。

myPromise
    .then(result => {
        console.log(result); // 输出: Operation successful
    })
    .catch(error => {
        console.error(error); // 如果失败，输出: Operation failed
    });

catch 方法

catch 方法用于捕获 Promise 链中的任何错误。

myPromise
    .then(result => {
        console.log(result);
    })
    .catch(error => {
        console.error(error);
    });

finally 方法

finally 方法用于注册一个无论成功还是失败都会执行的回调函数。

myPromise
    .then(result => {
        console.log(result);
    })
    .catch(error => {
        console.error(error);
    })
    .finally(() => {
        console.log("Promise is settled");
    });

支持链式调用

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

const promise1 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("Step 1 complete");
    }, 1000);
});
 
const promise2 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("Step 2 complete");
    }, 1000);
});
 
promise1
    .then(result1 => {
        console.log(result1); // 输出: Step 1 complete
        return promise2;
    })
    .then(result2 => {
        console.log(result2); // 输出: Step 2 complete
    })
    .catch(error => {
        console.error(error);
    });

常见的静态方法

Promise 还提供了一些静态方法，用于处理常见的异步操作：

• Promise.resolve(value)：返回一个已经成功（fulfilled）的 Promise。
• Promise.reject(reason)：返回一个已经失败（rejected）的 Promise。
• Promise.all(iterable)：返回一个在所有输入的 Promise 都成功时成功的 Promise，如果任何一个 Promise 失败，则返回失败的 Promise。
• Promise.race(iterable)：返回一个在第一个输入的 Promise 成功或失败时就结束的 Promise。

const promise1 = Promise.resolve("Success 1");
const promise2 = Promise.resolve("Success 2");
 
Promise.all([promise1, promise2])
    .then(results => {
        console.log(results); // 输出: ["Success 1", "Success 2"]
    })
    .catch(error => {
        console.error(error);
    });
 
const promise3 = Promise.resolve("First to resolve");
const promise4 = new Promise((resolve, reject) => {
    setTimeout(() => resolve("Second to resolve"), 500);
});
 
Promise.race([promise3, promise4])
    .then(result => {
        console.log(result); // 输出: First to resolve
    })
    .catch(error => {
        console.error(error);
    });

总结

Promise 是 JavaScript 中处理异步操作的强大工具。它提供了清晰的 API 和灵活的方法，使得异步代码更容易编写、阅读和维护。希望这些示例和解释能帮助你更好地理解和使用 Promise。如果有更多问题，欢迎大家留言！