Скачать или смотреть How to Execute Async Promises with a 10-Second Delay in JavaScript

Learn how to implement asynchronous promises in JavaScript with a delay between launches to prevent memory issues in your applications.
---
This video is based on the question https://stackoverflow.com/q/63706372/ asked by the user 'Bertijn Pauwels' ( https://stackoverflow.com/u/10207282/ ) and on the answer https://stackoverflow.com/a/63706549/ provided by the user '33-B01' ( https://stackoverflow.com/u/4978732/ ) 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: Async promises with delay in between starts

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.
---
Handling Async Promises with Delays in JavaScript

In the world of JavaScript, especially when working with asynchronous operations, developers often encounter challenges related to how multiple tasks are handled concurrently. A common issue arises when a script tries to run too many promises at once, resulting in performance problems such as memory heap overflow. This guide addresses a specific case where a developer needs to manage builds in Jenkins using Webpack, ensuring that a delay is introduced between each build to prevent overlaps and crashes.

The Problem Statement

The developer has a script that looks something like this:

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

In this code snippet, the developer is attempting to execute builds in parallel using Promise.all. While this approach optimizes time efficiency, it also leads to memory issues due to too many promises running simultaneously.

The requirement is straightforward: instead of executing all builds at once, the developer wants to execute each build one at a time with a 10-second delay between each start. This way, memory usage is kept in check, and performance remains stable.

The Solution Explained

To achieve this, we need to implement a waiting mechanism that introduces a 10-second delay between starting each promise. Thankfully, JavaScript's async/await syntax and setTimeout can be leveraged efficiently here. Let’s break down the solution into manageable steps.

Step 1: Creating a Delay Function

Firstly, we define a function that wraps setTimeout in a promise. This function will allow us to pause execution of our async code conveniently.

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

In this function:

We create a Promise that resolves after a specified duration, effectively pausing our async code execution temporarily.

Step 2: Using Async/Await in a Loop

Next, we transition to our main function where the builds are processed sequentially with a delay.

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

Key components here include:

An async function main() which allows us to use await within a loop.

A for...of loop that iterates over each package in the packages array sequentially.

After each buildWeb execution, we call await delay(10000), effectively pausing execution for 10 seconds before moving on to the next build.

Step 3: Running the Main Function

At the end of your script, you'd call the main function and handle any errors that may arise during execution:

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

This ensures that any potential issues are logged to the console, providing useful debugging information.

Conclusion

By introducing a simple delay mechanism and using async/await, we can manage our promises effectively, allowing builds to execute in a controlled manner. This approach not only addresses the memory issues caused by concurrent execution but also retains the benefits of JavaScript's asynchronous capabilities.

Implementing this method allows developers to manage large and resource-intensive operations without crashing the application, paving the way for smoother workflows, especially in environments like Jenkins with Webpack.

Now, you can confidently handle multiple async operations with appropriate delays, ensuring a more robust and efficient approach to your build processes!

Happy coding!