custom-writable-stream.js

100%

custom-writable-stream.js

✓ Published0🌍 Public

Last edited Nov 22, 2014

Created on Nov 22, 2014

This example demonstrates a custom Writable stream in Node.js that stores incoming data in an in-memory object. It shows how to extend the `stream.Writable` class, using `util.inherits` to create the `WMStrm` constructor, which initializes a `Buffer` for a given key. The overridden `_write` method concatenates each chunk, whether already a `Buffer` or converted from a string, to the stored buffer. The code then writes two strings to the stream, triggers the `finish` event, and logs the accumulated result from the `memStore` object.

AI-generated description

Similar vizzes

Loading thumbnail…

readStreams leaking in Node

This animation shows memory leaking in a Node.js process as it repeatedly creates read streams for a 2 MB file. Over 180 streams are spawned in a loop, each printing characters to indicate lifecycle events ('o' on open, '*' on data, '$' on end). Every 5 seconds, the script forces garbage collection via `--expose-gc` and logs the process’s resident set size (RSS) in megabytes, producing a stepwise upward trend that reveals how unclosed stream handlers accumulate and prevent memory from being reclaimed. The visualization renders this growth as an animated time series, highlighting the leak’s progression over time.

Aalessioalex

59% match

Loading thumbnail…

QueueWrite - asynchronous queue for stream output

The QueueWrite example demonstrates asynchronous stream throttling by piping the contents of `test.js` through a custom writable stream that queues chunks and limits concurrent write operations. A `delayPrint` function writes each chunk to stdout after a random delay of up to 200 milliseconds, while periodic console logs show the current open slot count and queue size. The code uses Node.js `stream.Writable`, `fs.createReadStream` with `lowWaterMark` and `highWaterMark` options, and `util.inherits` to implement the custom stream logic. Animation occurs through the timing of queued writes and the live stats output.

ZZJONSSON

58% match

Loading thumbnail…

custom-transform-stream.js

This example demonstrates a custom Node.js transform stream that computes a SHA-1 hash of incoming text data. The stream, named `ShaSum`, uses the `stream.Transform` base class and the `crypto.createHash` API to update the hash incrementally with each chunk. It writes two lines of input, then outputs the final hex digest to `process.stdout` via the `_flush` method, showing how transform streams can process data piecewise and emit a result only at the end.

Aalessioalex

58% match

Loading thumbnail…

Node read stream

This example streams the contents of a server log file directly to the browser as an HTTP response. It uses Node.js’s `fs.createReadStream` to read the file with UTF-8 encoding, then listens to the `'data'` event to strip newline characters and send each chunk via `res.send`. The code does not perform any visual rendering or charting; instead, it demonstrates a raw data-delivery pattern where log entries are pushed to the client in real time as they are read. No visualization library is involved.

Aalessioalex

54% match

Loading thumbnail…

Winston..

The example demonstrates a Node.js server setup that uses Winston for logging operations. It initializes a Winston logger with both console and file transports, writing log entries to `log/server.log` while also capturing exceptions to a separate file. The code shows how to create a logger instance via `winston.Logger`, configure transports like `winston.transports.Console` and `winston.transports.File`, and record messages using `logger.log('info', ...)` and `logger.info(...)`. The visible data source is the hardcoded log strings, with the rendering approach being text output to console and file.

Aalessioalex

53% match

Loading thumbnail…

Gist f43964c87050d00ea185f80513e0d34f

This example demonstrates a minimalist web page that pairs a red HTML block with a JavaScript-based memory system. The visualization shows how a custom `memory` object stores and retrieves key-value pairs, simulating a limited cache that forgets the oldest entries after 250 saves. The code uses plain JavaScript with no external libraries, relying on standard object properties and array methods like `shift()` and `push()` to manage memory. The page renders via a simple `index.html` file that loads `test.js`, which logs the stored data to the console. No charting or data-rendering APIs appear in the code.

Aagnott

53% match

Loading thumbnail…

Memcached in JavaScript based on Node.JS

This example visualizes the behavior of a Memcached server implemented in Node.js, showing how it manages key-value storage with an LRU (Least Recently Used) eviction strategy under memory pressure. The animation displays the element count in the cache, updating every two seconds via a `setInterval` callback. The code uses Node.js `net` module for TCP networking, a custom LRU class based on chriso/lru, and leverages `process.memoryUsage()` to monitor RSS memory. It also exposes a custom `gc` command to trigger garbage collection via `gc()`.

Aalessioalex

52% match

Loading thumbnail…

configurable-logger-example.js

This example demonstrates a configurable logger that prefixes messages with a custom string. The code defines a `createLogger` function that takes a prefix and returns a new logging function, which prepends that prefix to all subsequent arguments before delegating to the original `log` function. The `log` function itself uses `Array.prototype.slice.call` to handle variable arguments and joins them with spaces for console output via `console.log`. The example shows a logger created with the prefix `'MyApp ::'`, then invoked with multiple arguments to produce a prefixed message.

Aalessioalex

52% match