Understanding Why Execution Doesn't Stop at await in JavaScript's Async/Await

Explore the common confusion around `await` not seeming to pause execution in asynchronous JavaScript code and learn effective solutions to manage concurrent promises.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Why the execution doesn't stop at await (async/await JS)?

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Why Execution Doesn't Stop at await in JavaScript's Async/Await

When working with asynchronous JavaScript, many developers encounter the peculiar behavior where the execution seems to continue even after an await statement. This can be frustrating, particularly when the goal is to maintain control over concurrent function execution. In this post, we will demystify this behavior, explore an example involving a limited number of concurrent asynchronous functions, and suggest effective strategies to get your code working as intended.

The Problem

Let's say you have a series of asynchronous functions that you want to execute, but due to system constraints or performance reasons, you only want a limited number of these functions to run simultaneously. This is a common requirement in scenarios like making multiple API calls or processing batches of data concurrently.

In the provided example, the developer was using the runPromises function to execute a list of functions that return promises, attempting to limit the concurrent executions. However, they found that the execution of their code did not pause as expected at the await keyword.

Understanding The Issue

The root of the problem lies in the distinction between functions and promises:

Functions vs. Promises: The array used in the runPromises function (fns) contains functions that return promises, but the implementation expects an array of promises instead.

Therefore, most of the confusion stems from the fact that while the code appears to await the completion of a promise, it actually proceeds without waiting when called improperly.

Solution Breakdown

To address this issue, you can adopt one of two approaches:

Approach 1: Modify the runPromises Function

You can adjust the runPromises function to call the promise-returning functions at the time of execution. Here’s one way to do this effectively:

[[See Video to Reveal this Text or Code Snippet]]

In this adjustment, each function in the promises array is invoked with prom(), returning a promise that can be awaited correctly.

Approach 2: Change the Definition of fns

Alternatively, you could modify how you define the fns array:

[[See Video to Reveal this Text or Code Snippet]]

This way, you are passing an array of promises directly to the runPromises function, effectively eliminating any misunderstanding about the type of argument being passed.

Conclusion

Using async/await in JavaScript can greatly simplify asynchronous programming, but it’s crucial to understand how Promise objects interact with function calls and await. By ensuring that you are working with promises instead of functions that return promises, you can effectively control execution flow and concurrency in your code.

With these insights, you can now manage concurrent executions effectively while working with JavaScript's asynchronous nature. So go ahead, try implementing these strategies in your projects, and experience smoother asynchronous handling!