什么是JavaScript的Promise对象？

JavaScript的Promise对象是用于处理异步操作的一种解决方案，它代表了某个尚未完成但最终会完成的操作的结果。在ES6之前，JavaScript处理异步操作主要依赖回调函数，当异步操作嵌套层级过多时，就会出现回调地狱，代码可读性和可维护性都会大幅下降，而Promise就是为了解决这个问题而诞生的。

Promise的基本概念与状态

Promise本质上是一个对象，它有三个固定的状态，分别是：

• pending：初始状态，既没有被兑现，也没有被拒绝
• fulfilled：操作成功完成的状态，此时会有一个成功的结果值
• rejected：操作失败的状态，此时会有一个失败的原因

Promise的状态一旦从pending变为fulfilled或者rejected，就不会再发生改变，这也是Promise的核心特性之一，保证了异步操作结果的一致性。

创建Promise对象

我们可以通过Promise的构造函数来创建一个Promise实例，构造函数接收一个执行器函数作为参数，这个执行器函数会立即执行，它有两个参数，分别是resolve和reject，它们都是函数：

• resolve函数：当异步操作成功时调用，把Promise的状态从pending变为fulfilled，并把成功的结果传递出去
• reject函数：当异步操作失败时调用，把Promise的状态从pending变为rejected，并把失败的原因传递出去

下面是一个简单的创建Promise的示例，模拟一个异步请求操作：

// 创建一个模拟异步请求的Promise
const asyncRequest = new Promise((resolve, reject) => {
    // 模拟异步操作，比如接口请求
    setTimeout(() => {
        const isSuccess = Math.random() > 0.5;
        if (isSuccess) {
            // 操作成功，调用resolve传递结果
            resolve({
                code: 200,
                data: '请求成功返回的数据',
                message: '操作成功'
            });
        } else {
            // 操作失败，调用reject传递失败原因
            reject({
                code: 500,
                message: '请求失败，请稍后重试'
            });
        }
    }, 1000);
});

Promise的常用方法

then方法

then方法是Promise实例最常用的方法，它用来指定当Promise状态变为fulfilled时的回调函数，以及状态变为rejected时的回调函数。then方法接收两个可选的参数：

• 第一个参数：状态变为fulfilled时的回调，接收resolve传递的结果作为参数
• 第二个参数：状态变为rejected时的回调，接收reject传递的原因作为参数

then方法会返回一个新的Promise实例，所以可以进行链式调用，这也是Promise解决回调地狱的核心方式。

使用示例：

// 调用上面创建的asyncRequest Promise
asyncRequest.then(
    // 成功回调
    (result) => {
        console.log('请求成功:', result);
    },
    // 失败回调
    (error) => {
        console.log('请求失败:', error);
    }
);

catch方法

catch方法是专门用来捕获Promise状态变为rejected时的错误的，它相当于then方法的第二个参数的语法糖，但是catch的错误处理更灵活，它可以捕获前面所有then方法中抛出的错误。

使用示例：

asyncRequest
    .then((result) => {
        console.log('请求成功:', result);
        // 如果这里抛出错误，也会被后面的catch捕获
        // throw new Error('处理数据时出错');
    })
    .catch((error) => {
        console.log('捕获到错误:', error);
    });

finally方法

finally方法不管Promise最终的状态是fulfilled还是rejected，都会执行其中的回调函数，通常用于做一些清理工作，比如关闭加载动画、释放资源等。finally方法不接收任何参数，因为它不知道Promise最终是成功还是失败。

使用示例：

asyncRequest
    .then((result) => {
        console.log('请求成功:', result);
    })
    .catch((error) => {
        console.log('请求失败:', error);
    })
    .finally(() => {
        console.log('不管请求成功还是失败，都会执行这里的逻辑');
        // 比如关闭加载动画
    });

Promise的静态方法

除了实例方法，Promise还提供了几个常用的静态方法，方便处理多个Promise的场景。

Promise.all

Promise.all方法接收一个Promise数组作为参数，返回一个新的Promise实例。只有当数组中的所有Promise都变为fulfilled时，返回的Promise才会变为fulfilled，此时结果是一个数组，包含所有Promise的成功结果，顺序和传入的数组顺序一致。如果数组中有一个Promise变为rejected，那么返回的Promise会立即变为rejected，并且捕获到第一个被拒绝的Promise的错误原因。

使用示例：

const promise1 = Promise.resolve(1);
const promise2 = new Promise((resolve) => setTimeout(() => resolve(2), 1000));
const promise3 = new Promise((resolve) => setTimeout(() => resolve(3), 500));

Promise.all([promise1, promise2, promise3])
    .then((results) => {
        console.log('所有Promise都成功:', results); // 输出 [1, 2, 3]
    })
    .catch((error) => {
        console.log('有Promise失败:', error);
    });

Promise.race

Promise.race方法同样接收一个Promise数组作为参数，返回一个新的Promise实例。它会采用数组中第一个改变状态的Promise的结果，不管这个Promise是成功还是失败，返回的Promise的状态都会和它一致。

使用示例：

const promise1 = new Promise((resolve) => setTimeout(() => resolve('第一个完成'), 1000));
const promise2 = new Promise((resolve) => setTimeout(() => resolve('第二个完成'), 500));

Promise.race([promise1, promise2])
    .then((result) => {
        console.log('最先完成的Promise结果:', result); // 输出 第二个完成
    });

Promise.allSettled

Promise.allSettled方法接收一个Promise数组作为参数，返回一个新的Promise实例。它会等待数组中的所有Promise都改变状态（不管是fulfilled还是rejected）之后，才会变为fulfilled，结果是一个数组，每个元素对应每个Promise的结果，包含status属性和对应的value或者reason。

使用示例：

const promise1 = Promise.resolve(1);
const promise2 = Promise.reject('出错了');
const promise3 = new Promise((resolve) => setTimeout(() => resolve(3), 500));

Promise.allSettled([promise1, promise2, promise3])
    .then((results) => {
        console.log('所有Promise的最终状态:', results);
        // 输出：
        // [
        //   { status: 'fulfilled', value: 1 },
        //   { status: 'rejected', reason: '出错了' },
        //   { status: 'fulfilled', value: 3 }
        // ]
    });

Promise的使用注意事项

• Promise的执行器函数是同步执行的，里面的异步操作才会进入事件队列，不会阻塞主线程
• 不要在Promise的执行器函数里面抛出未被捕获的错误，最好用reject来传递错误原因
• 链式调用then的时候，如果前一个then返回一个Promise，那么下一个then会等待这个Promise的状态改变之后再执行
• 如果then方法里面返回的不是Promise，那么这个值会被当作下一个then的成功回调的参数

下面是一个链式调用的完整示例：

// 模拟一个获取用户信息的异步操作
function getUserInfo(userId) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (userId > 0) {
                resolve({ id: userId, name: '测试用户', age: 20 });
            } else {
                reject('用户ID不合法');
            }
        }, 500);
    });
}

// 模拟一个获取用户订单的异步操作
function getUserOrders(user) {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve([`${user.name}的订单1`, `${user.name}的订单2`]);
        }, 500);
    });
}

// 链式调用
getUserInfo(1)
    .then((user) => {
        console.log('获取用户信息成功:', user);
        // 返回一个新的Promise，用于获取用户订单
        return getUserOrders(user);
    })
    .then((orders) => {
        console.log('获取用户订单成功:', orders);
    })
    .catch((error) => {
        console.log('流程出错:', error);
    });

通过上面的内容，我们可以清楚地了解到JavaScript中Promise对象的基本概念、使用方法和常见场景。Promise让异步代码的逻辑更加线性化，避免了回调嵌套的问题，是前端开发中处理异步操作的重要工具，也是后续学习async/await语法的基础。

PromiseJavaScript异步编程then方法catch方法修改时间：2026-07-04 07:21:19