Sponsored
Sponsored
Time Complexity: O(1) since promise creation and resolution are constant time operations.
Space Complexity: O(1) as we only store a fixed number of numbers.
1function addTwoPromises(promise1, promise2) {
2 return PromiseIn this code, we first call `Promise.all` with an array of the two input promises promise1 and promise2. This returns a promise that resolves when both input promises resolve. We then use the `then` method to specify that when the promise resolves, it should sum the two resolved values and return the result.
Time Complexity: O(1) as each step essentially involves constant-time resolution.
Space Complexity: O(1) since we're working with a fixed number of variables.
1function addTwoPromises(promise1, promise2) {
2 return promise1.then(value1 => {
3 return promise2.then(value2 => {
4 return value1 + value2;
5 });
6 });
7}
8// Example usage:
9let promise1 = new Promise(resolve => setTimeout(() => resolve(10), 50));
10let promise2 = new Promise(resolve => setTimeout(() => resolve(-12), 30));
11addTwoPromises(promise1, promise2).then(console.log); // Output: -2This code captures each promise's resolution value one after the other by chaining the then method, first resolving promise1, storing its value, and then resolving promise2, accumulating the sum and returning it.
This approach utilizes the Promise.all() method, which takes an array of promises and returns a new promise that resolves when all of the promises in the array have resolved.
In this method, you pass both promise1 and promise2 to Promise.all(). It waits for both promises to resolve, then combines their resolved values using array destructuring to sum them up within the then() method.
Time Complexity: O(1), as all operations inside the promises are essentially constant time operations.
Space Complexity: O(1), space usage is constant regardless of input sizes.
1function addTwoPromises(promise1, promise2) {
2 return Promise.all([promise1, promise2]).then(values => {
3 return values[0] + values[1];
4 });
5}
6
7// Example Usage
8const promise1 = new Promise(resolve => setTimeout(() => resolve(2), 20));
9const promise2 = new Promise(resolve => setTimeout(() => resolve(5), 60));
10addTwoPromises(promise1, promise2).then(console.log); // Outputs: 7The function addTwoPromises takes two promises and returns a new promise that resolves to the sum of the values resolved by the input promises. The Promise.all method is used to wait for both promises to resolve, and the resolved values are extracted as an array within the then method.
This approach employs async/await, a cleaner syntax for handling promises in JavaScript. By using an async function, you can await the resolution of both promise1 and promise2 to get their values before summing them up.
Time Complexity: O(1), as the time taken by promise resolution does not scale with input data.
Space Complexity: O(1), as the function only stores a few values regardless of input.
1async function addTwoPromises(promise1, promise2) {
2 const value1 = await promise1;
3 const value2 = await promise2;
4 return value1 + value2;
5}
6
7// Example Usage
8const promise1 = new Promise(resolve => setTimeout(() => resolve(10), 50));
9const promise2 = new Promise(resolve => setTimeout(() => resolve(-12), 30));
10addTwoPromises(promise1, promise2).then(console.log); // Outputs: -2addTwoPromises is defined as an async function, meaning it returns a Promise and its execution can be paused using await. By awaiting both promise1 and promise2, the function captures their resolved values into value1 and value2. These are summed and the result is returned, thus promise chaining is implicit in every call.