Skip to main content
100%

Gist 7ef5a071200fae517638

✓ Published0🌍 Public
Aackuser
Last edited Jan 3, 2016
Created on Jan 3, 2016

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`.

AI-generated description

Similar vizzes

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
67% 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
67% match
Loading thumbnail…

settimeout-example.js

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.

Aalessioalex
66% 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
64% match
Loading thumbnail…

Gist d51a566a307b428d98eaf3aa8d2a59a3

This example benchmarks JavaScript event emitter libraries across multiple test scenarios, including initialization, emitting with context, and emitting single or multiple values to one or more listeners. The code runs benchmark suites using `benchmark.js`, comparing libraries such as `EventEmitter3`, `MiniSignals`, `push-stream`, and `signal-lite`, and reports throughput in operations per second. It highlights the fastest performers per scenario, such as `push-stream` leading in the "emit with context" test. The visualization shows raw performance data from Node.js 6.2.1, rendered as plain-text tables with pass/fail assertions and timing summaries.

HHypercubed
63% match
Loading thumbnail…

Gist f29bf45f379305fcac53a379776bc295

This example demonstrates a timed alert as a simple interaction test, showing how the code uses `setTimeout` to trigger a JavaScript alert after a three-second delay. The accompanying function `window.asdf` is defined but not invoked, leaving its intended behavior unspecified. The visualization relies on plain JavaScript and the browser’s native alert API rather than any external data or rendering library. The code is minimal, acting as a functional probe for event timing and global function scope.

PPatrick Wojda
61% match
Loading thumbnail…

Gist 5001434

This example shows a debugging scenario for event sourcing, where two events with identical timestamps are replayed and returned in unpredictable order. The code displays two event objects—`UserCreatedEvent` and `UserCredentialsCreatedEvent`—with their UUIDs and aggregate root IDs, using JavaScript object literals. It illustrates the problem of sorting by `DateTime.Utc.Now` when fast-sequenced commands produce equal dates, leading to logical ordering failures. The example renders the raw event data and aggregates as plain text, relying on standard JavaScript syntax rather than any visualization library, focusing on the conceptual issue of timestamp collisions in EventStore queries.

RRestuta
60% 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
60% match