LeetCode 2723. 两个 Promise 对象相加

给定两个 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)。