settimeout-example.js

100%

settimeout-example.js

✓ Published0🌍 Public

Last edited Nov 22, 2014

Created on Nov 22, 2014

This example demonstrates the use of `setTimeout` to schedule repeated asynchronous callbacks in JavaScript. It defines a `tellMeLater` function that loops ten times, invoking `setTimeout` with `log.bind(null, i)` to log each index after a 100-millisecond delay. The `log` function writes its argument to the console via `console.log`. The code shows how `Function.prototype.bind` creates a fixed argument for each scheduled call, ensuring the loop variable’s value is captured correctly despite the asynchronous execution.

AI-generated description

Similar vizzes

Loading thumbnail…

settimeout-iif.js

This example demonstrates how JavaScript’s closure scope preserves loop variable values inside asynchronous callbacks. The code defines a `tellMeLater` function that iterates ten times, each iteration wrapping a `setTimeout` call in an immediately-invoked function expression (IIFE). By passing `i` as an argument to the IIFE, each timeout callback logs its own unique index (0 through 9) after a 100-millisecond delay, avoiding the classic loop-variable capture problem. The example uses no external libraries, relying solely on native JavaScript `setTimeout` and `console.log` to show the expected sequential output.

Aalessioalex

85% match

Loading thumbnail…

Gist 7ef5a071200fae517638

This example demonstrates the execution order of Node.js timer and scheduling APIs by logging messages from `setTimeout`, `setImmediate`, and `process.nextTick`. The code creates an `EventEmitter` and schedules callbacks with zero-millisecond delays, including a nested `setTimeout` and `setImmediate` inside a 10-millisecond timeout. It shows how `process.nextTick` runs before `setImmediate`, while `setTimeout` and `setImmediate` ordering varies by context. The output is printed directly to the console using `console.log`.

Aackuser

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

64% match

Loading thumbnail…

setTimeout/setInterval experiment involving slow-downs

This example demonstrates how `setTimeout` and `setInterval` differ in their behavior when a callback runs longer than the specified interval. It shows that `setInterval` can queue overlapping calls, while `setTimeout` waits for the previous execution to finish. The visualization uses a counter and a select menu to switch between the two methods, with a checkbox to artificially slow down the `tick` function via a blocking `while` loop. The code relies on D3.js v4 for DOM selection and event handling, and uses `window.setTimeout` and `window.setInterval` to schedule the counter updates. The counter increments by 0.5 every 500 milliseconds.

HHerst

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

59% match

Loading thumbnail…

Async/await 1

This example demonstrates the sequential and delayed execution of JavaScript console logs using the native `setTimeout` function. The code first prints “แสดงอันแรก” immediately, then schedules a second message, “แสดงอัน الثاني (بعد الأول 1 ثانية),” to appear after a 1000-millisecond delay. The visualization shows how asynchronous timing controls the order of output, highlighting the difference between synchronous and callback-based execution in a minimal, text-based format. No external libraries are used; the behavior relies solely on the browser’s JavaScript runtime and the standard `console.log` API.

PPanJ

59% match

Loading thumbnail…

D3 Starter - Asynchronus

This example demonstrates asynchronous programming in JavaScript using Promise objects and the `setTimeout` API, showing how to handle operations that take time to complete. The code defines a `waitSeconds` function that returns a Promise resolving after a specified delay, then chains `.then()` to log a message once the time has elapsed. Using D3 v6 loaded from a CDN, the page includes explanatory text about asynchronous versus synchronous behavior, with no data visualization or rendering involved—the focus is purely on illustrating the callback and Promise patterns.

Mmaxthamt

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

58% match