Skip to main content
100%

Gist c38b5428350be0929bb330f44e6c9d82

✓ Published0🌍 Public
Aamazingandyyy
Last edited Nov 17, 2017
Created on Nov 17, 2017

This example contrasts two JavaScript approaches to looping over asynchronous tasks. It shows that an `async` loop with `await` inside a `for` loop executes each iteration sequentially, waiting for a five-second `setTimeout` before logging the next index, while a plain `Promise`-based loop fires all five calls concurrently, each logging after a two-second delay. The code uses native `async`/`await` and `Promise` constructors, with `setTimeout` simulating delay, and logs indices to the console. No external libraries or data sources are involved, highlighting raw JavaScript concurrency behavior.

AI-generated description

Similar vizzes

Loading thumbnail…

JavaScript: async/await with forEach()

This example demonstrates how to manage sequential asynchronous operations in JavaScript using `async/await` combined with a custom `asyncForEach` function. It shows a three-item array being processed one at a time, with each item logged to the console after a 50-millisecond delay imposed by the `waitFor` helper, which relies on `setTimeout` and a Promise. The `asyncForEach` function explicitly loops through the array with a `for` loop, awaiting the callback for each element, ensuring the `Done` message appears only after all items are processed. The code uses no external libraries, only native JavaScript Promise and timer APIs.

Aackuser
76% match
Loading thumbnail…

async-for-each

This example demonstrates a sequential asynchronous loop over an array, where each item is processed only after the previous callback completes. It shows how `asyncForEach` awaits a user-provided callback that delays execution using a custom `waitFor` promise wrapper around `setTimeout`. The code uses the native `async`/`await` syntax and a `for` loop to ensure the array `[1, 2, 3]` is logged in order, with a one-second pause between each item. The visible data source is a hardcoded array in the `start` function, and the rendering approach is console output.

AA6Brgeuka
75% match
Loading thumbnail…

Gist c0ec6bb768fd2672307b0807e4ee46fb

This example benchmarks four JavaScript loop styles—a standard `for` loop, a reversed `for` loop, a `for…of` loop, and `forEach`—on a fixed array of ten numbers. It measures execution time by repeating each loop a thousand times via `performance.now()` timestamps, accumulating the total milliseconds. The code defines each loop as a separate function and calls them through a `test` helper, logging the sum to the console. The comparison uses a simple in-memory data array, with no external libraries, focusing on raw loop performance in a JavaScript environment.

MMAKIO135
72% match
Loading thumbnail…

Gist 1075489a3f6f94d13b2ab76cff4c7cea

This example visualizes the asynchronous execution order of Node.js operations by logging their completion times relative to a shared start timestamp. It uses Node’s `https.request` to fetch Google’s homepage, `crypto.pbkdf2` for four CPU-intensive password hashes, and `fs.readFile` to read a local file. The console output reveals how the event loop interleaves I/O callbacks, with the network request finishing before the file read and hash computations, illustrating the non-blocking concurrency model.

Aamazingandyyy
71% match
Loading thumbnail…

Async/await 5

This example visualizes the flow of a sequential asynchronous function, showing how each awaited promise resolves in a chain before the next begins. The code defines an `async` function with three sequential `await` calls—`doA()`, `doB(a)`, and `doC(b)`—where each step passes its result into the next. The visualization maps this dependency chain, highlighting the blocking nature of each await and the data handoff between stages. It relies on JavaScript’s native `async`/`await` syntax, with no external libraries, and renders a linear timeline of the function’s execution order.

PPanJ
70% match
Loading thumbnail…

Async/await 6

The example shows an asynchronous JavaScript flow where the program awaits one operation, then runs two independent tasks in parallel via `Promise.all`. The code displays `doA()`, followed by `doB(a)` and `doC(a)` as the two concurrent calls after the first result resolves. It uses native `async`/`await` syntax with `Promise.all()` to coordinate these dependent and independent steps. No rendering library or data source is visible; the visualization focuses purely on the sequence and branching of these promises.

PPanJ
69% match
Loading thumbnail…

Sleep function in JavaScript (need node v7.10+, borrowed from https://twitter.com/samccone/status/859777976199659521)

This example demonstrates JavaScript’s async/await pattern for sequencing delayed actions, showing how a series of sleep calls pause execution before logging messages. It uses the native Promise constructor and setTimeout to implement a reusable sleep function, while async/await orchestrates the flow: the script logs “i am sleepy,” waits 5 seconds, logs “i need more sleep,” waits 10 seconds, then logs “all rested.” No external libraries or rendering are involved; the output is console-based, relying solely on Node.js v7.10+ runtime features.

TThomasG77
68% match
Loading thumbnail…

Gist 4ff85e89516594d9399c15b3c436878f

This example demonstrates JavaScript Promise patterns for asynchronous server communication, showing fetch(), .then(), .catch(), Promise.all/race, custom Promise construction, and async/await syntax. The code samples use the browser's built-in fetch() API against document.URL.toString() to simulate server checks, with console.log output for results and error handling. It also includes a setTimeout-based delay Promise example to illustrate timing control. The gist serves as educational reference material, contrasting Promise chains, custom Promise creation, and sugar-syntax async functions.

MMistyBlunch
68% match