给定两个 promise 对象 promise1 和 promise2，返回一个新的 promise。promise1 和 promise2 都会被解析为一个数字。返回的 Promise 应该解析为这两个数字的和。
示例 1：
输入： promise1 = new Promise(resolve => setTimeout(() => resolve(2), 20)), promise2 = new Promise(resolve => setTimeout(() => resolve(5), 60)) 输出：7 解释：两个输入的 Promise 分别解析为值 2 和 5。返回的 Promise 应该解析为 2 + 5 = 7。返回的 Promise 解析的时间不作为判断条件。
promise1 和 promise2 都是被解析为一个数字的 promise 对象
注：Promise是JavaScript中的内容，用于表示异步操作的最终完成（或失败）并允许我们在结果可用时处理这些操作。它们是以更有组织和结构的方式处理异步代码的一种方法。Promise有三种状态：挂起（pending）、已完成（fulfilled）或拒绝（rejected）： 1.挂起：Promise的初始状态，表示异步操作仍在进行中，尚未完成。
2.已完成：Promise的状态，表示异步操作成功完成，意味着 promises的结果或值可用。
3.拒绝：Promise的状态，表示异步操作遇到错误或失败， promises的结果无法获得。Promise提供了像 .then() 和 .catch() 这样的方法来处理已解析的值或错误。
通常，使用Promise时会遇到async和await关键字，它们用于简化Promise的使用，使异步代码看起来更像同步代码： 1.async：用于定义异步函数，确保函数始终返回一个Promise。当在函数声明或函数表达式前使用async关键字时，它变成一个异步函数。请注意，从异步函数返回的非Promise对象会自动包装成Promise对象。
2.await：用于暂停异步函数的执行，直到Promise解析。它只能在异步函数内部使用。当在Promise之前使用await时，它等待Promise解析或拒绝。如果已解析，它继续执行下一行代码；如果等待的Promise被拒绝，将抛出异常。使用await允许您以更顺序且可读的方式编写异步代码，而无需使用.then()显式链接Promise。
当需要同时执行多个异步操作并等待它们全部完成，通常会使用Promise.all()方法。
Promise.all()方法用于同时处理多个Promise。它以一个Promise数组（或可迭代对象）作为输入，并返回一个新的Promise，在输入数组中的所有Promise都已解析时才会解析。
Promise.all()方法将等待所有Promise解决（无论是fulfilled还是rejected）。如果所有Promise都被解决，返回的Promise也会被解决，而输入Promise的已解析值将按照输入Promise的顺序作为数组可用。
请注意：Promise.all()不仅接受Promise作为输入，还可以接受只包含数字的数组，它将解析这些数字，例如：
await Promise.all([1, 2, Promise.resolve(3), Promise.resolve(4)]).then((value) => {
console.log(value)
}, (error) => {
console.log(error)
})
以上代码先用Promise.resolve创建了两个已经解决的Promise对象，分别包含值3和4；之后的Promise.all接受了一个包含多个Promise对象和普通值的数组，创建了一个新的Promise对象，新的Promise对象会在所有输入的Promise都解决（或其中一个拒绝）后解决，在这里，它包含了两个普通值（1和2）和两个已经解决的Promise（3和4）；await关键字用于等待一个Promise解决，在这里，await等待Promise.all的解决；一旦Promise.all的所有Promise都被解决，.then()方法就会被调用，.then方法接受了两个回调函数作为参数，第一个回调函数是所有Promise被解决时调用的，它接受一个参数value，参数value是一个包含所有Promise解决值的数组；如果有任何一个Promise被拒绝，或者其中一个Promise抛出了异常，.then()的第二个参数，即错误处理的回调函数，就会被调用。
使用Promise.all()允许有效并行执行多个异步操作，并在它们全部可用后处理合并的结果。
例如，当应用程序需要同时从多个API获取数据时，可以使用Promise.all()来并行启动所有请求并等待所有响应。一旦所有Promise都被解决，应用程序可以处理合并数据。
法一：使用Promise.all创建一个新的Promise，该Promise在Promise1和Promise2都被解决后解决，使用Promise.all时，我们使用await等待Promise1和Promise2都被解决。一旦由Promise.all()返回的Promise被满足，promise1和promise2的已解析值将以数组的形式可用。使用解构赋值，分别将这些值分配给res1和res2变量，最后，我们返回res1和res2的和：
/**
* @param {Promise} promise1
* @param {Promise} promise2
* @return {Promise}
*/
var addTwoPromises = async function(promise1, promise2) {
try
{
const [res1, res2] = await Promise.all([promise1, promise2]);
return res1 + res2;
}
catch (error)
{
console.error(error);
throw error; // 重新抛出错误以保持将错误传播给调用者的行为
}
};
/**
* addTwoPromises(Promise.resolve(2), Promise.resolve(2))
* .then(console.log); // 4
*/
此算法时间复杂度为O(max(promise1,promise2))，取决于解析时间较长的那个Promise；空间复杂度为O(1)。
法二：仅使用await分别等待Promise1和Promise2的解析，此方法比法一更慢，因为法一是并行同时等待Promise1和Promise2的执行，而本方法按顺序执行两个Promise，即一个执行完后再执行另一个：
/**
* @param {Promise} promise1
* @param {Promise} promise2
* @return {Promise}
*/
var addTwoPromises = async function(promise1, promise2) {
try
{
return await promise1 + await promise2;
}
catch (error)
{
console.error(error);
throw error; // 重新抛出错误以保持将错误传播给调用者的行为
}
};
/**
* addTwoPromises(Promise.resolve(2), Promise.resolve(2))
* .then(console.log); // 4
*/
此算法时间复杂度为O(promise1+promise2)，两个Promise串行执行；空间复杂度为O(1)。
法三：使用Promise.then()方法链接Promise：
/**
* @param {Promise} promise1
* @param {Promise} promise2
* @return {Promise}
*/
var addTwoPromises = async function(promise1, promise2) {
try
{
return promise1.then((value1) => promise2.then((value2) => value1 + value2));
}
catch (error)
{
console.error(error);
throw error; // 重新抛出错误以保持将错误传播给调用者的行为
}
};
/**
* addTwoPromises(Promise.resolve(2), Promise.resolve(2))
* .then(console.log); // 4
*/
此算法时间复杂度为O(promise1+promise2)，两个Promise串行执行；空间复杂度为O(1)。
法四：我们可以并行处理promise1和promise2的解决，并累积结果，即我们可以使用计数器来跟踪已解决的Promise数量，一旦所有Promise都已解决，它将使用累积的结果解决新的Promise：
/**
* @param {Promise} promise1
* @param {Promise} promise2
* @return {Promise}
*/
var addTwoPromises = async function(promise1, promise2) {
return new Promise((resolve, reject) => {
let count = 2;
let res = 0;
[promise1, promise2].forEach(async promise => {
try
{
const subRes = await promise;
res += subRes;
--count;
if (count == 0)
{
resolve(res);
}
}
catch (err)
{
reject(err);
}
});
});
};
/**
* addTwoPromises(Promise.resolve(2), Promise.resolve(2))
* .then(console.log); // 4
*/
以上代码创建了一个新Promise对象，并在其构造函数中执行了一个迭代，resolve和reject是Promise的构造函数提供的回调函数，用于控制Promise的状态，resolve的作用是将Promise的状态从待定（pending）变为已解决（fulfilled），reject的作用是将Promise的状态从待定（pending）变为已拒绝（rejected）。对于每个Promise，使用async等待其解决值，这个过程是并行的。此算法时间复杂度为O(max(promise1,promise2))，取决于解析时间较长的那个Promise；空间复杂度为O(1)。
精彩链接
您阅读本篇文章共花了：
发表评论