Скачать или смотреть Why does an async callback in a for loop only execute once?

Discover why an `async` callback may only run a single time in a loop and learn how to modify your code for intended functionality.
---
This video is based on the question https://stackoverflow.com/q/68271865/ asked by the user 'Milan Smolík' ( https://stackoverflow.com/u/6349994/ ) and on the answer https://stackoverflow.com/a/68272029/ provided by the user 'Silvermind' ( https://stackoverflow.com/u/858757/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

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 does an async callback in for cycle only execute once?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Why does an async callback in a for loop only execute once?

If you're delving into the world of JavaScript async functions, you may encounter a perplexing issue: why does an async callback within a for loop only execute a single time? This situation can produce confusion, especially when you're trying to retry an action after a failure. Let's explore this common problem, discern its underlying cause, and provide an effective solution to ensure your callbacks behave as expected.

The Problem at Hand

Consider the following scenario when working with Selenium in JavaScript (or TypeScript). You have a function designed to retry an action until it either succeeds or reaches a maximum number of attempts. Your structure may look something like this:

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

In this code, the goal is to perform an action, catch any expected errors, execute a waitingAction, and retry the action again. However, even if the loop runs 200 times, it appears that your waitingAction executes only once. This can lead to a frustrating debugging journey, as this behavior contradicts your intentions.

Understanding the Issue

The crux of the issue lies in how the action and waitingAction are defined and utilized within the loop. In the current implementation, you've passed promises directly to your poll function. Here's why this leads to the observed behavior:

Promises are Immediate: When a promise is created, it begins executing immediately. Therefore, when you pass the action and waitingAction as promises, they're executed only once at the start of the loop.

Reusability: Since promises can't be reused, once action is executed and fails, the same promise is never created again for subsequent iterations.

The Solution: Utilize Delegates

To resolve this issue, you can modify your poll function to accept functions (delegates) that return promises instead of accepting the promises directly. This way, you ensure that a new promise is created on each iteration of the loop. Here’s how you can refactor the code:

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

Updated Call Example

To call this new poll function, you would structure it like this:

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

Conclusion

Understanding the behavior of promises in asynchronous programming, particularly in JavaScript, can be challenging. The key takeaway here is that passing functions that return promises—rather than the promises themselves—ensures that each iteration of your for loop operates as intended. By utilizing this strategy, you can enhance your code's reliability and maintainability, allowing repeated attempts at an action until success or failure.

Adopting this simple adjustment will save you from unexpected bugs and make your experience with async programming much smoother.