Why Choose `return await promise` over `return promise` in JavaScript?

return await promise vs. return promise in JavaScript: Behavioral Differences

Introduction

When working with asynchronous code in JavaScript, developers often use the async/await mechanisms to manage Promises. However, there are two variations to consider when returning a Promise in an async function: return await promise and return promise. This article delves into the nuances between these approaches.

Behavioural Differences

In most cases, there is no noticeable difference between return await promise and return promise. Both will yield a Promise that resolves or rejects, providing the same observable behaviour.

However, a distinction becomes apparent when using try-catch blocks. Consider this example:

async function rejectionWithReturnAwait() {
  try {
    return await Promise.reject(new Error());
  } catch (e) {
    return 'Saved!';
  }
}

In this case, return await ensures that the rejected Promise is caught within the async function, allowing the catch clause to be executed and returning a Promise that resolves to "Saved!".

async function rejectionWithReturn() {
  try {
    return Promise.reject(new Error());
  } catch (e) {
    return 'Saved!';
  }
}

In contrast, return promise returns the rejected Promise directly without awaiting it within the async function. This means that the rejection is not captured by the catch clause, and the caller receives the rejection instead.

Implications

The choice between return await promise and return promise depends on the desired behaviour. If error handling within the async function is crucial, return await promise should be used to ensure that errors are caught and handled accordingly. Otherwise, return promise can be used to optimise performance by avoiding unnecessary nesting.

The above is the detailed content of Why Choose `return await promise` over `return promise` in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!