Serially Iterating An Array, Asynchronously

100%

Serially Iterating An Array, Asynchronously

✓ Published0🌍 Public

Last edited Feb 9, 2016

Created on Feb 9, 2016

This example demonstrates a pattern for processing an array of asynchronous steps sequentially, where each step must finish before the next begins. It shows a recursive function, `run`, that takes an array of functions (`steps`), a shared `data` object, and a completion callback (`done`). The function shifts the first step from the array, invokes it with the data and a callback, and on success recursively calls itself with the remaining steps. If a step returns an error, the recursion halts and passes the error to `done`. The code uses plain JavaScript callbacks and array mutation via `shift()`, with no external libraries.

AI-generated description

Similar vizzes

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

68% match

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

66% match

Loading thumbnail…

simple-parallel-control-flow.js

This example demonstrates a minimal asynchronous control-flow pattern using a counter-based callback mechanism. It shows how a JavaScript function can coordinate multiple parallel tasks by decrementing a shared counter, invoking a final callback only when all tasks complete. The `doParallel` function initializes the counter and returns a closure; each call to `next()` reduces the counter, and when it reaches zero, the callback logs `"ok"` to the console. The code uses plain JavaScript with no external libraries, highlighting a simple, dependency-free approach to parallel execution.

Aalessioalex

60% match

Loading thumbnail…

Gist 7d6a7404e99051bb7d2f36c61f0113ae

This example demonstrates functional programming techniques in JavaScript, including currying, composition, and generator functions. It shows how currying enables partial application, as seen with the `sum` function and reusable helpers like `getName` and `mapUserNames`. The code uses `compose` with `reduceRight` to chain array transformations, filtering user names by length. It also illustrates generator behavior with `next(true)` to control iteration completion. The data is a hardcoded array of user objects, and output is logged to the console via `console.log`.

IIliaIdakiev

59% match

Loading thumbnail…

run promises sequentially or not using observables

This example demonstrates how to execute arrays of promises sequentially or in controlled batches using RxJS observables. It shows a stream of numeric values piped through operators like `map`, `defer`, and `mergeAll` with a concurrency limit of 1, ensuring each promise resolves before the next starts. A second variant uses `bufferCount(3)` to group the input into batches of three, still processing them one batch at a time. The `delay` helper creates promises that log their resolved values to the console, with a final `console.log('done')` indicating stream completion.

RRestuta

58% match

Loading thumbnail…

Gist c38b5428350be0929bb330f44e6c9d82

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.

Aamazingandyyy

58% match

Loading thumbnail…

JS Arrays

This example demonstrates JavaScript array manipulation through a simple range function. The code defines a `range(start, stop, step)` function that iterates from a start value to a stop value, pushing each step increment into an array using a for loop and the `array.push()` method. The main script calls `console.log` to output the result of `range(2,5,1)` to the browser console. It shows the fundamental use of basic JavaScript syntax and array operations within an HTML environment, relying on no external libraries.

Ppirani.sabah@gmail.com

58% 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

57% match