企业常用系统网络优化app

Promise对象在JavaScript中是一种处理异步操作的方式，它提供了一组方法来管理和控制异步操作的结果。以下是一些常用的Promise方法：

以下是对 constructor(executor)‌、then(onFulfilled, onRejected）、catch(onRejected)‌、 finally(onFinally)‌、all(iterable)‌、race(iterable)‌、 resolve(value)‌、 reject(reason)‌、allSettled(iterable)‌、any(iterable)‌ 这些方法的讲解

‌constructor(executor)‌：

这是Promise的构造函数，用于创建一个新的Promise实例。executor是一个执行器函数，它接收两个函数作为参数：resolve和reject。resolve在异步操作成功时被调用，将Promise的状态设置为fulfilled；reject在异步操作失败时被调用，将Promise的状态设置为rejected。

const promise = new Promise((resolve, reject) => {setTimeout(() => {resolve('Success!');// 或者在某些情况下调用 reject('Error!');}, 1000);
});promise.then(value => console.log(value)); // 输出: Success!

then(onFulfilled, onRejected)‌：

then方法为Promise对象注册回调函数，处理异步操作成功（fulfilled）或失败（rejected）的情况。它返回一个新的Promise对象，这使得我们可以进行链式调用。
onFulfilled是成功时的回调函数，接收异步操作成功时的结果。
onRejected（可选）是失败时的回调函数，接收异步操作失败时的原因。

const promise = new Promise((resolve, reject) => {setTimeout(() => {resolve('Data loaded');}, 1000);
});promise.then(value => console.log(value), // 成功时的回调error => console.error(error) // 失败时的回调（可选）
);
// 输出: Data loaded

catch(onRejected)‌：

catch方法是.then(null, onRejected)的语法糖，用于捕获Promise链中的错误，并处理它们。它接受一个回调函数作为参数，该函数将在Promise链中的某个地方发生错误时被调用。

const promise = new Promise((resolve, reject) => {setTimeout(() => {reject(new Error('Something went wrong'));}, 1000);
});promise.catch(error => console.error(error.message));
// 输出: Something went wrong

finally(onFinally)‌：

finally方法用于指定不管Promise对象最后状态如何，都会执行的操作。它接受一个回调函数作为参数，该回调函数不接受任何参数。

const promise = new Promise((resolve, reject) => {setTimeout(() => {resolve('Operation completed');}, 1000);
});promise.then(value => console.log(value)).catch(error => console.error(error)).finally(() => console.log('Cleanup operations'));
// 输出: 
// Operation completed
// Cleanup operations

all(iterable)‌：

all方法用于处理多个Promise对象。它接受一个可迭代对象（如数组）作为参数，这个可迭代对象包含多个Promise对象。只有当所有的Promise对象都成功完成时，它才会成功；如果任何一个Promise对象失败，它立即失败并返回第一个失败的错误。

const promise1 = Promise.resolve('First value');
const promise2 = new Promise((resolve) => setTimeout(resolve, 1000, 'Second value'));
const promise3 = Promise.reject('Third value failed');Promise.all([promise1, promise2]).then(values => console.log(values)).catch(error => console.error(error));
// 输出: 
// ['First value', 'Second value']
// （注意：promise3 被排除在外，因为它拒绝了）

race(iterable)‌：

race方法同样用于处理多个Promise对象。它接受一个可迭代对象作为参数。与all方法不同的是，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(value => console.log(value));
// 输出: Second （时间短100ms）

resolve(value)‌：

resolve方法返回一个以给定值解析后的Promise对象。如果这个值是一个Promise对象，那么resolve方法会返回这个Promise对象；否则，它返回一个以该值为结果的新Promise对象。‌

const promise = Promise.resolve('Already resolved');promise.then(value => console.log(value));
// 输出: Already resolved

reject(reason)‌：

reject方法返回一个以给定原因拒绝的Promise对象。‌

const promise = Promise.reject(new Error('Already rejected'));promise.catch(error => console.error(error.message));
// 输出: Already rejected

allSettled(iterable)‌：

allSettled方法==用于处理多个Promise对象，并返回一个在所有给定的Promise对象都已经完成（不管是fulfilled还是rejected）时解析的新Promise对象。==这个新的Promise对象解析的结果是一个对象数组，每个对象都表示对应的Promise对象的结果。

const promise1 = Promise.resolve('Success!');
const promise2 = Promise.reject('Failure!');Promise.allSettled([promise1, promise2]).then(results => {results.forEach((result) => console.log(result));});
// 输出:
// {status: 'fulfilled', value: 'Success!'}
// {status: 'rejected', reason: 'Failure!'}

any(iterable)‌：

any方法用于处理多个Promise对象，并返回一个在任意一个给定的Promise对象成功完成时解析的新Promise对象。如果所有的Promise对象都失败，它才会失败，并返回第一个失败的错误。

const promise1 = Promise.reject('First failed');
const promise2 = new Promise((resolve) => setTimeout(resolve, 1000, 'Second succeeded'));
const promise3 = Promise.reject('Third failed');Promise.any([promise1, promise2, promise3]).then(value => console.log(value)).catch(error => console.error(error));
// 输出: Second succeeded