Скачать или смотреть Achieving a Non-Blocking While Loop in JavaScript with Async Functions

Explore how to create a `non-blocking while loop` using a recursive approach in JavaScript, improving API request handling. Understand error handling and optimizations with Promises and async-await patterns for Node.js projects.
---
This video is based on the question https://stackoverflow.com/q/71821058/ asked by the user 'Matteo Barberis' ( https://stackoverflow.com/u/18318546/ ) and on the answer https://stackoverflow.com/a/71821083/ provided by the user 'CertainPerformance' ( https://stackoverflow.com/u/9515207/ ) 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: Is this the correct way to write a non-blocking while loop using try-catch, setTimeout and recursion?

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.
---
Building a Non-Blocking While Loop in JavaScript

When working with server-side JavaScript, particularly in environments like Node.js, developers often encounter situations where a task might fail due to external factors. One common case is when we need to send data to an API, but sometimes the associated resources (e.g., data on IPFS) take longer to retrieve than expected, causing the request to fail. So, how can we retry a failed operation without blocking other requests? Here's how you can do it with a non-blocking while loop using recursion, setTimeout, and async-await.

The Problem

Imagine you have an /order endpoint that, when triggered, is responsible for forwarding an order to an external API. If the request fails, you want to retry sending the order a specified number of times until it either succeeds or reaches the maximum retry count. However, implementing a typical while loop would block the entire Node.js event loop, hindering other incoming requests. The challenge is to design a solution that allows for retrying failed orders without blocking the execution of your server.

The Initial Approach

You might consider using recursive functions and setTimeout to implement a non-blocking retry mechanism. The following is an example of how one might attempt to achieve this:

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

Here, if the order sending fails, the function retries after a 3-minute delay. However, this implementation has some significant flaws that we need to address.

Key Issues with the Initial Implementation

Promise Resolution Timing: The recursive call inside the setTimeout does not properly handle the Promise chaining. This results in returning a Promise that resolves straight after the first failed call instead of waiting for all retries to finish.

Error Handling: If all retry attempts fail, the code does not reject the promise. This means the calling function can't easily implement error handling logic.

Sequential Processing: The current implementation of fetching line items sequentially waits for each item one at a time, which can be inefficient, especially if the data retrieval takes substantial time.

Improved Solution

To address the issues outlined above, we can promisify our retry mechanism and use Promise.all for fetching multiple templates simultaneously, allowing us to write more efficient and readable code.

Step 1: Implementing Delay with Promises

We will define a delay function that returns a Promise and use await to pause execution.

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

Step 2: Refactoring the makeOrder function

Now, let's refactor the makeOrder function to utilize this delay and improve error handling:

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

Key Improvements

Chained Promises: Now the retry mechanism correctly returns the Promise from the recursive call, allowing for proper error propagation and handling.

Improved Performance: By using Promise.all, we can fetch multiple item templates concurrently, significantly improving performance.

Error Handling for Maximum Tries: The function now explicitly throws an error if all tries are exhausted, enabling the caller to handle failures appropriately.

Conclusion

With these refinements, you've successfully created a non-blocking retry mechanism for handling API requests in JavaScript. Leveraging async-await, Promises, and recursion allows you to build robust server-side applications that can gracefully deal with external failures while maintaining responsiveness to incoming requests.

If you're dealing with similar issu