A stream is an abstract interface for working with streaming data in Node.js.\nThe stream module provides a base API that makes it easy to build objects\nthat implement the stream interface.
There are many stream objects provided by Node.js. For instance, a\n[request to an HTTP server][http-incoming-message] and [process.stdout][]\nare both stream instances.
Streams can be readable, writable, or both. All streams are instances of\n[EventEmitter][].
The stream module can be accessed using:
const stream = require('stream');\nWhile it is important for all Node.js users to understand how streams works,\nthe stream module itself is most useful for developers that are creating new\ntypes of stream instances. Developer's who are primarily consuming stream\nobjects will rarely (if ever) have need to use the stream module directly.
This document is divided into two primary sections and third section for\nadditional notes. The first section explains the elements of the stream API that\nare required to use streams within an application. The second section explains\nthe elements of the API that are required to implement new types of streams.
\n", "type": "module", "displayName": "Organization of this document" }, { "textRaw": "Types of Streams", "name": "types_of_streams", "desc": "There are four fundamental stream types within Node.js:
\nfs.createReadStream()][]).fs.createWriteStream()][]).net.Socket][]).zlib.createDeflate()][]).All streams created by Node.js APIs operate exclusively on strings and Buffer\nobjects. It is possible, however, for stream implementations to work with other\ntypes of JavaScript values (with the exception of null which serves a special\npurpose within streams). Such streams are considered to operate in "object\nmode".
Stream instances are switched into object mode using the objectMode option\nwhen the stream is created. Attempting to switch an existing stream into\nobject mode is not safe.
Both [Writable][] and [Readable][] streams will store data in an internal\nbuffer that can be retrieved using writable._writableState.getBuffer() or\nreadable._readableState.buffer, respectively.
The amount of data potentially buffered depends on the highWaterMark option\npassed into the streams constructor. For normal streams, the highWaterMark\noption specifies a total number of bytes. For streams operating in object mode,\nthe highWaterMark specifies a total number of objects.
Data is buffered in Readable streams when the implementation calls\n[stream.push(chunk)][stream-push]. If the consumer of the Stream does not\ncall [stream.read()][stream-read], the data will sit in the internal\nqueue until it is consumed.
Once the total size of the internal read buffer reaches the threshold specified\nby highWaterMark, the stream will temporarily stop reading data from the\nunderlying resource until the data currently buffered can be consumed (that is,\nthe stream will stop calling the internal readable._read() method that is\nused to fill the read buffer).
Data is buffered in Writable streams when the\n[writable.write(chunk)][stream-write] method is called repeatedly. While the\ntotal size of the internal write buffer is below the threshold set by\nhighWaterMark, calls to writable.write() will return true. Once the\nthe size of the internal buffer reaches or exceeds the highWaterMark, false\nwill be returned.
A key goal of the stream API, and in particular the [stream.pipe()] method,\nis to limit the buffering of data to acceptable levels such that sources and\ndestinations of differing speeds will not overwhelm the available memory.
Because [Duplex][] and [Transform][] streams are both Readable and Writable,\neach maintain two separate internal buffers used for reading and writing,\nallowing each side to operate independently of the other while maintaining an\nappropriate and efficient flow of data. For example, [net.Socket][] instances\nare [Duplex][] streams whose Readable side allows consumption of data received\nfrom the socket and whose Writable side allows writing data to the socket.\nBecause data may be written to the socket at a faster or slower rate than data\nis received, it is important each side operate (and buffer) independently of\nthe other.
Almost all Node.js applications, no matter how simple, use streams in some\nmanner. The following is an example of using streams in a Node.js application\nthat implements an HTTP server:
\nconst http = require('http');\n\nconst server = http.createServer( (req, res) => {\n // req is an http.IncomingMessage, which is a Readable Stream\n // res is an http.ServerResponse, which is a Writable Stream\n\n let body = '';\n // Get the data as utf8 strings.\n // If an encoding is not set, Buffer objects will be received.\n req.setEncoding('utf8');\n\n // Readable streams emit 'data' events once a listener is added\n req.on('data', (chunk) => {\n body += chunk;\n });\n\n // the end event indicates that the entire body has been received\n req.on('end', () => {\n try {\n const data = JSON.parse(body);\n } catch (er) {\n // uh oh! bad json!\n res.statusCode = 400;\n return res.end(`error: ${er.message}`);\n }\n\n // write back something interesting to the user:\n res.write(typeof data);\n res.end();\n });\n});\n\nserver.listen(1337);\n\n// $ curl localhost:1337 -d '{}'\n// object\n// $ curl localhost:1337 -d '"foo"'\n// string\n// $ curl localhost:1337 -d 'not json'\n// error: Unexpected token o\n[Writable][] streams (such as res in the example) expose methods such as\nwrite() and end() that are used to write data onto the stream.
[Readable][] streams use the [EventEmitter][] API for notifying application\ncode when data is available to be read off the stream. That available data can\nbe read from the stream in multiple ways.
Both [Writable][] and [Readable][] streams use the [EventEmitter][] API in\nvarious ways to communicate the current state of the stream.
[Duplex][] and [Transform][] streams are both [Writable][] and [Readable][].
\nApplications that are either writing data to or consuming data from a stream\nare not required to implement the stream interfaces directly and will generally\nhave no reason to call require('stream').
Developers wishing to implement new types of streams should refer to the\nsection [API for Stream Implementers][].
\n", "miscs": [ { "textRaw": "Writable Streams", "name": "writable_streams", "desc": "Writable streams are an abstraction for a destination to which data is\nwritten.
\nExamples of [Writable][] streams include:
\nprocess.stdout][], [process.stderr][]Note: Some of these examples are actually [Duplex][] streams that implement\nthe [Writable][] interface.
\nAll [Writable][] streams implement the interface defined by the\nstream.Writable class.
While specific instances of [Writable][] streams may differ in various ways,\nall Writable streams follow the same fundamental usage pattern as illustrated\nin the example below:
\nconst myStream = getWritableStreamSomehow();\nmyStream.write('some data');\nmyStream.write('some more data');\nmyStream.end('done writing data');\nThe 'close' event is emitted when the stream and any of its underlying\nresources (a file descriptor, for example) have been closed. The event indicates\nthat no more events will be emitted, and no further computation will occur.
Not all Writable streams will emit the 'close' event.
If a call to [stream.write(chunk)][stream-write] returns false, the\n'drain' event will be emitted when it is appropriate to resume writing data\nto the stream.
// Write the data to the supplied writable stream one million times.\n// Be attentive to back-pressure.\nfunction writeOneMillionTimes(writer, data, encoding, callback) {\n let i = 1000000;\n write();\n function write() {\n var ok = true;\n do {\n i--;\n if (i === 0) {\n // last time!\n writer.write(data, encoding, callback);\n } else {\n // see if we should continue, or wait\n // don't pass the callback, because we're not done yet.\n ok = writer.write(data, encoding);\n }\n } while (i > 0 && ok);\n if (i > 0) {\n // had to stop early!\n // write some more once it drains\n writer.once('drain', write);\n }\n }\n}\nThe 'error' event is emitted if an error occurred while writing or piping\ndata. The listener callback is passed a single Error argument when called.
Note: The stream is not closed when the 'error' event is emitted.
The 'finish' event is emitted after the [stream.end()][stream-end] method\nhas been called, and all data has been flushed to the underlying system.
const writer = getWritableStreamSomehow();\nfor (var i = 0; i < 100; i ++) {\n writer.write('hello, #${i}!\\n');\n}\nwriter.end('This is the end\\n');\nwriter.on('finish', () => {\n console.error('All writes are now complete.');\n});\nThe 'pipe' event is emitted when the [stream.pipe()][] method is called on\na readable stream, adding this writable to its set of destinations.
const writer = getWritableStreamSomehow();\nconst reader = getReadableStreamSomehow();\nwriter.on('pipe', (src) => {\n console.error('something is piping into the writer');\n assert.equal(src, reader);\n});\nreader.pipe(writer);\nThe 'unpipe' event is emitted when the [stream.unpipe()][] method is called\non a [Readable][] stream, removing this [Writable][] from its set of\ndestinations.
const writer = getWritableStreamSomehow();\nconst reader = getReadableStreamSomehow();\nwriter.on('unpipe', (src) => {\n console.error('Something has stopped piping into the writer.');\n assert.equal(src, reader);\n});\nreader.pipe(writer);\nreader.unpipe(writer);\nThe writable.cork() method forces all written data to be buffered in memory.\nThe buffered data will be flushed when either the [stream.uncork()][] or\n[stream.end()][stream-end] methods are called.
The primary intent of writable.cork() is to avoid a situation where writing\nmany small chunks of data to a stream do not cause a backup in the internal\nbuffer that would have an adverse impact on performance. In such situations,\nimplementations that implement the writable._writev() method can perform\nbuffered writes in a more optimized manner.
Calling the writable.end() method signals that no more data will be written\nto the [Writable][]. The optional chunk and encoding arguments allow one\nfinal additional chunk of data to be written immediately before closing the\nstream. If provided, the optional callback function is attached as a listener\nfor the ['finish'][] event.
Calling the [stream.write()][stream-write] method after calling\n[stream.end()][stream-end] will raise an error.
// write 'hello, ' and then end with 'world!'\nconst file = fs.createWriteStream('example.txt');\nfile.write('hello, ');\nfile.end('world!');\n// writing more now is not allowed!\nThe writable.setDefaultEncoding() method sets the default encoding for a\n[Writable][] stream.
The writable.uncork() method flushes all data buffered since\n[stream.cork()][] was called.
When using writable.cork() and writable.uncork() to manage the buffering\nof writes to a stream, it is recommended that calls to writable.uncork() be\ndeferred using process.nextTick(). Doing so allows batching of all\nwritable.write() calls that occur within a given Node.js event loop phase.
stream.cork();\nstream.write('some ');\nstream.write('data ');\nprocess.nextTick(() => stream.uncork());\nIf the writable.cork() method is called multiple times on a stream, the same\nnumber of calls to writable.uncork() must be called to flush the buffered\ndata.
stream.cork();\nstream.write('some ');\nstream.cork();\nstream.write('data ');\nprocess.nextTick(() => {\n stream.uncork();\n // The data will not be flushed until uncork() is called a second time.\n stream.uncork();\n});\nThe writable.write() method writes some data to the stream, and calls the\nsupplied callback once the data has been fully handled. If an error\noccurs, the callback may or may not be called with the error as its\nfirst argument. To reliably detect write errors, add a listener for the\n'error' event.
The return value indicates whether the written chunk was buffered internally\nand the buffer has exceeded the highWaterMark configured when the stream was\ncreated. If false is returned, further attempts to write data to the stream\nshould be paused until the ['drain'][] event is emitted.
A Writable stream in object mode will always ignore the encoding argument.
Readable streams are an abstraction for a source from which data is\nconsumed.
\nExamples of Readable streams include:
\nprocess.stdin][]All [Readable][] streams implement the interface defined by the\nstream.Readable class.
Readable streams effectively operate in one of two modes: flowing and paused.
\nWhen in flowing mode, data is read from the underlying system automatically\nand provided to an application as quickly as possible using events via the\n[EventEmitter][] interface.
In paused mode, the [stream.read()][stream-read] method must be called\nexplicitly to read chunks of data from the stream.
All [Readable][] streams begin in paused mode but can be switched to flowing\nmode in one of the following ways:
\n'data'][] event handler.stream.resume()][stream-resume] method.stream.pipe()][] method to send the data to a [Writable][].The Readable can switch back to paused mode using one of the following:
\nstream.pause()][stream-pause] method.'data'][] event\nhandlers, and removing all pipe destinations by calling the\n[stream.unpipe()][] method.The important concept to remember is that a Readable will not generate data\nuntil a mechanism for either consuming or ignoring that data is provided. If\nthe consuming mechanism is disabled or taken away, the Readable will attempt\nto stop generating the data.
\nNote: For backwards compatibility reasons, removing ['data'][] event\nhandlers will not automatically pause the stream. Also, if there are piped\ndestinations, then calling [stream.pause()][stream-pause] will not guarantee\nthat the stream will remain paused once those destinations drain and ask for\nmore data.
Note: If a [Readable][] is switched into flowing mode and there are no\nconsumers available handle the data, that data will be lost. This can occur,\nfor instance, when the readable.resume() method is called without a listener\nattached to the 'data' event, or when a 'data' event handler is removed\nfrom the stream.
The "two modes" of operation for a Readable stream are a simplified abstraction\nfor the more complicated internal state management that is happening within the\nReadable stream implementation.
\nSpecifically, at any given point in time, every Readable is in one of three\npossible states:
\nreadable._readableState.flowing = nullreadable._readableState.flowing = falsereadable._readableState.flowing = trueWhen readable._readableState.flowing is null, no mechanism for consuming the\nstreams data is provided so the stream will not generate its data.
Attaching a listener for the 'data' event, calling the readable.pipe()\nmethod, or calling the readable.resume() method will switch\nreadable._readableState.flowing to true, causing the Readable to begin\nactively emitting events as data is generated.
Calling readable.pause(), readable.unpipe(), or receiving "back pressure"\nwill cause the readable._readableState.flowing to be set as false,\ntemporarily halting the flowing of events but not halting the generation of\ndata.
While readable._readableState.flowing is false, data may be accumulating\nwithin the streams internal buffer.
The Readable stream API evolved across multiple Node.js versions and provides\nmultiple methods of consuming stream data. In general, developers should choose\none of the methods of consuming data and should never use multiple methods\nto consume data from a single stream.
\nUse of the readable.pipe() method is recommended for most users as it has been\nimplemented to provide the easiest way of consuming stream data. Developers that\nrequire more fine-grained control over the transfer and generation of data can\nuse the [EventEmitter][] and readable.pause()/readable.resume() APIs.
The 'close' event is emitted when the stream and any of its underlying\nresources (a file descriptor, for example) have been closed. The event indicates\nthat no more events will be emitted, and no further computation will occur.
Not all [Readable][] streams will emit the 'close' event.
The 'data' event is emitted whenever the stream is relinquishing ownership of\na chunk of data to a consumer. This may occur whenever the stream is switched\nin flowing mode by calling readable.pipe(), readable.resume(), or by\nattaching a listener callback to the 'data' event. The 'data' event will\nalso be emitted whenever the readable.read() method is called and a chunk of\ndata is available to be returned.
Attaching a 'data' event listener to a stream that has not been explicitly\npaused will switch the stream into flowing mode. Data will then be passed as\nsoon as it is available.
The listener callback will be passed the chunk of data as a string if a default\nencoding has been specified for the stream using the\nreadable.setEncoding() method; otherwise the data will be passed as a\nBuffer.
const readable = getReadableStreamSomehow();\nreadable.on('data', (chunk) => {\n console.log(`Received ${chunk.length} bytes of data.`);\n});\nThe 'end' event is emitted when there is no more data to be consumed from\nthe stream.
Note: The 'end' event will not be emitted unless the data is\ncompletely consumed. This can be accomplished by switching the stream into\nflowing mode, or by calling [stream.read()][stream-read] repeatedly until\nall data has been consumed.
const readable = getReadableStreamSomehow();\nreadable.on('data', (chunk) => {\n console.log(`Received ${chunk.length} bytes of data.`);\n});\nreadable.on('end', () => {\n console.log('There will be no more data.');\n});\nThe 'error' event may be emitted by a Readable implementation at any time.\nTypically, this may occur if the underlying stream in unable to generate data\ndue to an underlying internal failure, or when a stream implementation attempts\nto push an invalid chunk of data.
The listener callback will be passed a single Error object.
The 'readable' event is emitted when there is data available to be read from\nthe stream. In some cases, attaching a listener for the 'readable' event will\ncause some amount of data to be read into an internal buffer.
const readable = getReadableStreamSomehow();\nreadable.on('readable', () => {\n // there is some data to read now\n});\nThe 'readable' event will also be emitted once the end of the stream data\nhas been reached but before the 'end' event is emitted.
Effectively, the 'readable' event indicates that the stream has new\ninformation: either new data is available or the end of the stream has been\nreached. In the former case, [stream.read()][stream-read] will return the\navailable data. In the latter case, [stream.read()][stream-read] will return\nnull. For instance, in the following example, foo.txt is an empty file:
const fs = require('fs');\nconst rr = fs.createReadStream('foo.txt');\nrr.on('readable', () => {\n console.log('readable:', rr.read());\n});\nrr.on('end', () => {\n console.log('end');\n});\nThe output of running this script is:
\n$ node test.js\nreadable: null\nend\nNote: In general, the readable.pipe() and 'data' event mechanisms are\npreferred over the use of the 'readable' event.
The readable.isPaused() method returns the current operating state of the\nReadable. This is used primarily by the mechanism that underlies the\nreadable.pipe() method. In most typical cases, there will be no reason to\nuse this method directly.
const readable = new stream.Readable\n\nreadable.isPaused() // === false\nreadable.pause()\nreadable.isPaused() // === true\nreadable.resume()\nreadable.isPaused() // === false\nThe readable.pause() method will cause a stream in flowing mode to stop\nemitting ['data'][] events, switching out of flowing mode. Any data that\nbecomes available will remain in the internal buffer.
const readable = getReadableStreamSomehow();\nreadable.on('data', (chunk) => {\n console.log(`Received ${chunk.length} bytes of data.`);\n readable.pause();\n console.log('There will be no additional data for 1 second.');\n setTimeout(() => {\n console.log('Now data will start flowing again.');\n readable.resume();\n }, 1000);\n});\nThe readable.pipe() method attaches a [Writable][] stream to the readable,\ncausing it to switch automatically into flowing mode and push all of its data\nto the attached [Writable][]. The flow of data will be automatically managed so\nthat the destination Writable stream is not overwhelmed by a faster Readable\nstream.
The following example pipes all of the data from the readable into a file\nnamed file.txt:
const readable = getReadableStreamSomehow();\nconst writable = fs.createWriteStream('file.txt');\n// All the data from readable goes into 'file.txt'\nreadable.pipe(writable);\nIt is possible to attach multiple Writable streams to a single Readable stream.
\nThe readable.pipe() method returns a reference to the destination stream\nmaking it possible to set up chains of piped streams:
const r = fs.createReadStream('file.txt');\nconst z = zlib.createGzip();\nconst w = fs.createWriteStream('file.txt.gz');\nr.pipe(z).pipe(w);\nBy default, [stream.end()][stream-end] is called on the destination Writable\nstream when the source Readable stream emits ['end'][], so that the\ndestination is no longer writable. To disable this default behavior, the end\noption can be passed as false, causing the destination stream to remain open,\nas illustrated in the following example:
reader.pipe(writer, { end: false });\nreader.on('end', () => {\n writer.end('Goodbye\\n');\n});\nOne important caveat is that if the Readable stream emits an error during\nprocessing, the Writable destination is not closed automatically. If an\nerror occurs, it will be necessary to manually close each stream in order\nto prevent memory leaks.
\nNote: The [process.stderr][] and [process.stdout][] Writable streams are\nnever closed until the Node.js process exits, regardless of the specified\noptions.
The readable.read() method pulls some data out of the internal buffer and\nreturns it. If no data available to be read, null is returned. By default,\nthe data will be returned as a Buffer object unless an encoding has been\nspecified using the readable.setEncoding() method or the stream is operating\nin object mode.
The optional size argument specifies a specific number of bytes to read. If\nsize bytes are not available to be read, null will be returned unless\nthe stream has ended, in which case all of the data remaining in the internal\nbuffer will be returned (even if it exceeds size bytes).
If the size argument is not specified, all of the data contained in the\ninternal buffer will be returned.
The readable.read() method should only be called on Readable streams operating\nin paused mode. In flowing mode, readable.read() is called automatically until\nthe internal buffer is fully drained.
const readable = getReadableStreamSomehow();\nreadable.on('readable', () => {\n var chunk;\n while (null !== (chunk = readable.read())) {\n console.log(`Received ${chunk.length} bytes of data.`);\n }\n});\nIn general, it is recommended that developers avoid the use of the 'readable'\nevent and the readable.read() method in favor of using either\nreadable.pipe() or the 'data' event.
A Readable stream in object mode will always return a single item from\na call to [readable.read(size)][stream-read], regardless of the value of the\nsize argument.
Note: If the readable.read() method returns a chunk of data, a 'data'\nevent will also be emitted.
Note: Calling [stream.read([size])][stream-read] after the ['end'][]\nevent has been emitted will return null. No runtime error will be raised.
The readable.resume() method causes an explicitly paused Readable stream to\nresume emitting ['data'][] events, switching the stream into flowing mode.
The readable.resume() method can be used to fully consume the data from a\nstream without actually processing any of that data as illustrated in the\nfollowing example:
getReadableStreamSomehow()\n .resume()\n .on('end', () => {\n console.log('Reached the end, but did not read anything.');\n });\nThe readable.setEncoding() method sets the default character encoding for\ndata read from the Readable stream.
Setting an encoding causes the stream data\nto be returned as string of the specified encoding rather than as Buffer\nobjects. For instance, calling readable.setEncoding('utf8') will cause the\noutput data will be interpreted as UTF-8 data, and passed as strings. Calling\nreadable.setEncoding('hex') will cause the data to be encoded in hexadecimal\nstring format.
The Readable stream will properly handle multi-byte characters delivered through\nthe stream that would otherwise become improperly decoded if simply pulled from\nthe stream as Buffer objects.
Encoding can be disabled by calling readable.setEncoding(null). This approach\nis useful when working with binary data or with large multi-byte strings spread\nout over multiple chunks.
const readable = getReadableStreamSomehow();\nreadable.setEncoding('utf8');\nreadable.on('data', (chunk) => {\n assert.equal(typeof chunk, 'string');\n console.log('got %d characters of string data', chunk.length);\n});\nThe readable.unpipe() method detaches a Writable stream previously attached\nusing the [stream.pipe()][] method.
If the destination is not specified, then all pipes are detached.
If the destination is specified, but no pipe is set up for it, then\nthe method does nothing.
const readable = getReadableStreamSomehow();\nconst writable = fs.createWriteStream('file.txt');\n// All the data from readable goes into 'file.txt',\n// but only for the first second\nreadable.pipe(writable);\nsetTimeout(() => {\n console.log('Stop writing to file.txt');\n readable.unpipe(writable);\n console.log('Manually close the file stream');\n writable.end();\n}, 1000);\nThe readable.unshift() method pushes a chunk of data back into the internal\nbuffer. This is useful in certain situations where a stream is being consumed by\ncode that needs to "un-consume" some amount of data that it has optimistically\npulled out of the source, so that the data can be passed on to some other party.
Note: The stream.unshift(chunk) method cannot be called after the\n['end'][] event has been emitted or a runtime error will be thrown.
Developers using stream.unshift() often should consider switching to\nuse of a [Transform][] stream instead. See the [API for Stream Implementers][]\nsection for more information.
// Pull off a header delimited by \\n\\n\n// use unshift() if we get too much\n// Call the callback with (error, header, stream)\nconst StringDecoder = require('string_decoder').StringDecoder;\nfunction parseHeader(stream, callback) {\n stream.on('error', callback);\n stream.on('readable', onReadable);\n const decoder = new StringDecoder('utf8');\n var header = '';\n function onReadable() {\n var chunk;\n while (null !== (chunk = stream.read())) {\n var str = decoder.write(chunk);\n if (str.match(/\\n\\n/)) {\n // found the header boundary\n var split = str.split(/\\n\\n/);\n header += split.shift();\n const remaining = split.join('\\n\\n');\n const buf = Buffer.from(remaining, 'utf8');\n if (buf.length)\n stream.unshift(buf);\n stream.removeListener('error', callback);\n stream.removeListener('readable', onReadable);\n // now the body of the message can be read from the stream.\n callback(null, header, stream);\n } else {\n // still reading the header.\n header += str;\n }\n }\n }\n}\nNote: Unlike [stream.push(chunk)][stream-push], stream.unshift(chunk)\nwill not end the reading process by resetting the internal reading state of the\nstream. This can cause unexpected results if readable.unshift() is called\nduring a read (i.e. from within a [stream._read()][stream-_read]\nimplementation on a custom stream). Following the call to readable.unshift()\nwith an immediate [stream.push('')][stream-push] will reset the reading state\nappropriately, however it is best to simply avoid calling readable.unshift()\nwhile in the process of performing a read.
Versions of Node.js prior to v0.10 had streams that did not implement the\nentire stream module API as it is currently defined. (See [Compatibility][]\nfor more information.)
When using an older Node.js library that emits ['data'][] events and has a\n[stream.pause()][stream-pause] method that is advisory only, the\nreadable.wrap() method can be used to create a [Readable][] stream that uses\nthe old stream as its data source.
It will rarely be necessary to use readable.wrap() but the method has been\nprovided as a convenience for interacting with older Node.js applications and\nlibraries.
For example:
\nconst OldReader = require('./old-api-module.js').OldReader;\nconst Readable = require('stream').Readable;\nconst oreader = new OldReader;\nconst myReader = new Readable().wrap(oreader);\n\nmyReader.on('readable', () => {\n myReader.read(); // etc.\n});\nDuplex streams are streams that implement both the [Readable][] and\n[Writable][] interfaces.
\nExamples of Duplex streams include:
\nTransform streams are [Duplex][] streams where the output is in some way\nrelated to the input. Like all [Duplex][] streams, Transform streams\nimplement both the [Readable][] and [Writable][] interfaces.
\nExamples of Transform streams include:
\nThe stream module API has been designed to make it possible to easily\nimplement streams using JavaScript's prototypical inheritance model.
First, a stream developer would declare a new JavaScript class that extends one\nof the four basic stream classes (stream.Writable, stream.Readable,\nstream.Duplex, or stream.Transform), making sure the call the appropriate\nparent class constructor:
const Writable = require('stream').Writable;\n\nclass MyWritable extends Writable {\n constructor(options) {\n super(options);\n }\n}\nThe new stream class must then implement one or more specific methods, depending\non the type of stream being created, as detailed in the chart below:
\n| \n Use-case \n | \n \n Class \n | \n \n Method(s) to implement \n | \n
|---|---|---|
| \n Reading only \n | \n \n \n | \n\n
| \n
| \n Writing only \n | \n \n \n | \n\n
| \n
| \n Reading and writing \n | \n \n \n | \n\n
| \n
| \n Operate on written data, then read the result \n | \n \n \n | \n\n
| \n
Note: The implementation code for a stream should never call the "public"\nmethods of a stream that are intended for use by consumers (as described in\nthe [API for Stream Consumers][] section). Doing so may lead to adverse\nside effects in application code consuming the stream.
\n", "miscs": [ { "textRaw": "Simplified Construction", "name": "simplified_construction", "desc": "For many simple cases, it is possible to construct a stream without relying on\ninheritance. This can be accomplished by directly creating instances of the\nstream.Writable, stream.Readable, stream.Duplex or stream.Transform\nobjects and passing appropriate methods as constructor options.
For example:
\nconst Writable = require('stream').Writable;\n\nconst myWritable = new Writable({\n write(chunk, encoding, callback) {\n // ...\n }\n});\nThe stream.Writable class is extended to implement a [Writable][] stream.
Custom Writable streams must call the new stream.Writable([options])\nconstructor and implement the writable._write() method. The\nwritable._writev() method may also be implemented.
For example:
\nconst Writable = require('stream').Writable;\n\nclass MyWritable extends Writable {\n constructor(options) {\n // Calls the stream.Writable() constructor\n super(options);\n }\n}\nOr, when using pre-ES6 style constructors:
\nconst Writable = require('stream').Writable;\nconst util = require('util');\n\nfunction MyWritable(options) {\n if (!(this instanceof MyWritable))\n return new MyWritable(options);\n Writable.call(this, options);\n}\nutil.inherits(MyWritable, Writable);\nOr, using the Simplified Constructor approach:
\nconst Writable = require('stream').Writable;\n\nconst myWritable = new Writable({\n write(chunk, encoding, callback) {\n // ...\n },\n writev(chunks, callback) {\n // ...\n }\n});\nAll Writable stream implementations must provide a\n[writable._write()][stream-_write] method to send data to the underlying\nresource.
Note: [Transform][] streams provide their own implementation of the\n[writable._write()][stream-_write].
Note: This function MUST NOT be called by application code directly. It\nshould be implemented by child classes, and called only by the internal Writable\nclass methods only.
\nThe callback method must be called to signal either that the write completed\nsuccessfully or failed with an error. The first argument passed to the\ncallback must be the Error object if the call failed or null if the\nwrite succeeded.
It is important to note that all calls to writable.write() that occur between\nthe time writable._write() is called and the callback is called will cause\nthe written data to be buffered. Once the callback is invoked, the stream will\nemit a ['drain'][] event. If a stream implementation is capable of processing\nmultiple chunks of data at once, the writable._writev() method should be\nimplemented.
If the decodeStrings property is set in the constructor options, then\nchunk may be a string rather than a Buffer, and encoding will\nindicate the character encoding of the string. This is to support\nimplementations that have an optimized handling for certain string\ndata encodings. If the decodeStrings property is explicitly set to false,\nthe encoding argument can be safely ignored, and chunk will always be a\nBuffer.
The writable._write() method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.
Note: This function MUST NOT be called by application code directly. It\nshould be implemented by child classes, and called only by the internal Writable\nclass methods only.
\nThe writable._writev() method may be implemented in addition to\nwritable._write() in stream implementations that are capable of processing\nmultiple chunks of data at once. If implemented, the method will be called with\nall chunks of data currently buffered in the write queue.
The writable._writev() method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.
It is recommended that errors occurring during the processing of the\nwritable._write() and writable._writev() methods are reported by invoking\nthe callback and passing the error as the first argument. This will cause an\n'error' event to be emitted by the Writable. Throwing an Error from within\nwritable._write() can result in expected and inconsistent behavior depending\non how the stream is being used. Using the callback ensures consistent and\npredictable handling of errors.
const Writable = require('stream').Writable;\n\nconst myWritable = new Writable({\n write(chunk, encoding, callback) {\n if (chunk.toString().indexOf('a') >= 0) {\n callback(new Error('chunk is invalid'));\n } else {\n callback();\n }\n }\n});\nThe following illustrates a rather simplistic (and somewhat pointless) custom\nWritable stream implementation. While this specific Writable stream instance\nis not of any real particular usefulness, the example illustrates each of the\nrequired elements of a custom [Writable][] stream instance:
\nconst Writable = require('stream').Writable;\n\nclass MyWritable extends Writable {\n constructor(options) {\n super(options);\n }\n\n _write(chunk, encoding, callback) {\n if (chunk.toString().indexOf('a') >= 0) {\n callback(new Error('chunk is invalid'));\n } else {\n callback();\n }\n }\n}\nThe stream.Readable class is extended to implement a [Readable][] stream.
Custom Readable streams must call the new stream.Readable([options])\nconstructor and implement the readable._read() method.
For example:
\nconst Readable = require('stream').Readable;\n\nclass MyReadable extends Readable {\n constructor(options) {\n // Calls the stream.Readable(options) constructor\n super(options);\n }\n}\nOr, when using pre-ES6 style constructors:
\nconst Readable = require('stream').Readable;\nconst util = require('util');\n\nfunction MyReadable(options) {\n if (!(this instanceof MyReadable))\n return new MyReadable(options);\n Readable.call(this, options);\n}\nutil.inherits(MyReadable, Readable);\nOr, using the Simplified Constructor approach:
\nconst Readable = require('stream').Readable;\n\nconst myReadable = new Readable({\n read(size) {\n // ...\n }\n});\nNote: This function MUST NOT be called by application code directly. It\nshould be implemented by child classes, and called only by the internal Readable\nclass methods only.
\nAll Readable stream implementations must provide an implementation of the\nreadable._read() method to fetch data from the underlying resource.
When readable._read() is called, if data is available from the resource, the\nimplementation should begin pushing that data into the read queue using the\n[this.push(dataChunk)][stream-push] method. _read() should continue reading\nfrom the resource and pushing data until readable.push() returns false. Only\nwhen _read() is called again after it has stopped should it resume pushing\nadditional data onto the queue.
Note: Once the readable._read() method has been called, it will not be\ncalled again until the [readable.push()][stream-push] method is called.
The size argument is advisory. For implementations where a "read" is a\nsingle operation that returns data can use the size argument to determine how\nmuch data to fetch. Other implementations may ignore this argument and simply\nprovide data whenever it becomes available. There is no need to "wait" until\nsize bytes are available before calling [stream.push(chunk)][stream-push].
The readable._read() method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.
When chunk is a Buffer or string, the chunk of data will be added to the\ninternal queue for users of the stream to consume. Passing chunk as null\nsignals the end of the stream (EOF), after which no more data can be written.
When the Readable is operating in paused mode, the data added with\nreadable.push() can be read out by calling the\n[readable.read()][stream-read] method when the ['readable'][] event is\nemitted.
When the Readable is operating in flowing mode, the data added with\nreadable.push() will be delivered by emitting a 'data' event.
The readable.push() method is designed to be as flexible as possible. For\nexample, when wrapping a lower-level source that provides some form of\npause/resume mechanism, and a data callback, the low-level source can be wrapped\nby the custom Readable instance as illustrated in the following example:
// source is an object with readStop() and readStart() methods,\n// and an `ondata` member that gets called when it has data, and\n// an `onend` member that gets called when the data is over.\n\nclass SourceWrapper extends Readable {\n constructor(options) {\n super(options);\n\n this._source = getLowlevelSourceObject();\n\n // Every time there's data, push it into the internal buffer.\n this._source.ondata = (chunk) => {\n // if push() returns false, then stop reading from source\n if (!this.push(chunk))\n this._source.readStop();\n };\n\n // When the source ends, push the EOF-signaling `null` chunk\n this._source.onend = () => {\n this.push(null);\n };\n }\n // _read will be called when the stream wants to pull more data in\n // the advisory size argument is ignored in this case.\n _read(size) {\n this._source.readStart();\n }\n}\nNote: The readable.push() method is intended be called only by Readable\nImplementers, and only from within the readable._read() method.
It is recommended that errors occurring during the processing of the\nreadable._read() method are emitted using the 'error' event rather than\nbeing thrown. Throwing an Error from within readable._read() can result in\nexpected and inconsistent behavior depending on whether the stream is operating\nin flowing or paused mode. Using the 'error' event ensures consistent and\npredictable handling of errors.
const Readable = require('stream').Readable;\n\nconst myReadable = new Readable({\n read(size) {\n if (checkSomeErrorCondition()) {\n process.nextTick(() => this.emit('error', err));\n return;\n }\n // do some work\n }\n});\nThe following is a basic example of a Readable stream that emits the numerals\nfrom 1 to 1,000,000 in ascending order, and then ends.
\nconst Readable = require('stream').Readable;\n\nclass Counter extends Readable {\n constructor(opt) {\n super(opt);\n this._max = 1000000;\n this._index = 1;\n }\n\n _read() {\n var i = this._index++;\n if (i > this._max)\n this.push(null);\n else {\n var str = '' + i;\n var buf = Buffer.from(str, 'ascii');\n this.push(buf);\n }\n }\n}\nA [Duplex][] stream is one that implements both [Readable][] and [Writable][],\nsuch as a TCP socket connection.
\nBecause JavaScript does not have support for multiple inheritance, the\nstream.Duplex class is extended to implement a [Duplex][] stream (as opposed\nto extending the stream.Readable and stream.Writable classes).
Note: The stream.Duplex class prototypically inherits from stream.Readable\nand parasitically from stream.Writable.
Custom Duplex streams must call the new stream.Duplex([options])\nconstructor and implement both the readable._read() and\nwritable._write() methods.
For example:
\nconst Duplex = require('stream').Duplex;\n\nclass MyDuplex extends Duplex {\n constructor(options) {\n super(options);\n }\n}\nOr, when using pre-ES6 style constructors:
\nconst Duplex = require('stream').Duplex;\nconst util = require('util');\n\nfunction MyDuplex(options) {\n if (!(this instanceof MyDuplex))\n return new MyDuplex(options);\n Duplex.call(this, options);\n}\nutil.inherits(MyDuplex, Duplex);\nOr, using the Simplified Constructor approach:
\nconst Duplex = require('stream').Duplex;\n\nconst myDuplex = new Duplex({\n read(size) {\n // ...\n },\n write(chunk, encoding, callback) {\n // ...\n }\n});\nThe following illustrates a simple example of a Duplex stream that wraps a\nhypothetical lower-level source object to which data can be written, and\nfrom which data can be read, albeit using an API that is not compatible with\nNode.js streams.\nThe following illustrates a simple example of a Duplex stream that buffers\nincoming written data via the [Writable][] interface that is read back out\nvia the [Readable][] interface.
\nconst Duplex = require('stream').Duplex;\nconst kSource = Symbol('source');\n\nclass MyDuplex extends Duplex {\n constructor(source, options) {\n super(options);\n this[kSource] = source;\n }\n\n _write(chunk, encoding, callback) {\n // The underlying source only deals with strings\n if (Buffer.isBuffer(chunk))\n chunk = chunk.toString(encoding);\n this[kSource].writeSomeData(chunk, encoding);\n callback();\n }\n\n _read(size) {\n this[kSource].fetchSomeData(size, (data, encoding) => {\n this.push(Buffer.from(data, encoding));\n });\n }\n}\nThe most important aspect of a Duplex stream is that the Readable and Writable\nsides operate independently of one another despite co-existing within a single\nobject instance.
\n", "type": "module", "displayName": "An Example Duplex Stream" }, { "textRaw": "Object Mode Duplex Streams", "name": "object_mode_duplex_streams", "desc": "For Duplex streams, objectMode can be set exclusively for either the Readable\nor Writable side using the readableObjectMode and writableObjectMode options\nrespectively.
In the following example, for instance, a new Transform stream (which is a\ntype of [Duplex][] stream) is created that has an object mode Writable side\nthat accepts JavaScript numbers that are converted to hexidecimal strings on\nthe Readable side.
\nconst Transform = require('stream').Transform;\n\n// All Transform streams are also Duplex Streams\nconst myTransform = new Transform({\n writableObjectMode: true,\n\n transform(chunk, encoding, callback) {\n // Coerce the chunk to a number if necessary\n chunk |= 0;\n\n // Transform the chunk into something else.\n const data = chunk.toString(16);\n\n // Push the data onto the readable queue.\n callback(null, '0'.repeat(data.length % 2) + data);\n }\n});\n\nmyTransform.setEncoding('ascii');\nmyTransform.on('data', (chunk) => console.log(chunk));\n\nmyTransform.write(1);\n // Prints: 01\nmyTransform.write(10);\n // Prints: 0a\nmyTransform.write(100);\n // Prints: 64\nA [Transform][] stream is a [Duplex][] stream where the output is computed\nin some way from the input. Examples include [zlib][] streams or [crypto][]\nstreams that compress, encrypt, or decrypt data.
\nNote: There is no requirement that the output be the same size as the input,\nthe same number of chunks, or arrive at the same time. For example, a\nHash stream will only ever have a single chunk of output which is\nprovided when the input is ended. A zlib stream will produce output\nthat is either much smaller or much larger than its input.
The stream.Transform class is extended to implement a [Transform][] stream.
The stream.Transform class prototypically inherits from stream.Duplex and\nimplements its own versions of the writable._write() and readable._read()\nmethods. Custom Transform implementations must implement the\n[transform._transform()][stream-_transform] method and may also implement\nthe [transform._flush()][stream-_flush] method.
Note: Care must be taken when using Transform streams in that data written\nto the stream can cause the Writable side of the stream to become paused if\nthe output on the Readable side is not consumed.
\n", "methods": [ { "textRaw": "new stream.Transform([options])", "type": "method", "name": "Transform", "signatures": [ { "params": [ { "textRaw": "`options` {Object} Passed to both Writable and Readable constructors. Also has the following fields: ", "options": [ { "textRaw": "`transform` {Function} Implementation for the [`stream._transform()`][stream-_transform] method. ", "name": "transform", "type": "Function", "desc": "Implementation for the [`stream._transform()`][stream-_transform] method." }, { "textRaw": "`flush` {Function} Implementation for the [`stream._flush()`][stream-_flush] method. ", "name": "flush", "type": "Function", "desc": "Implementation for the [`stream._flush()`][stream-_flush] method." } ], "name": "options", "type": "Object", "desc": "Passed to both Writable and Readable constructors. Also has the following fields:", "optional": true } ] }, { "params": [ { "name": "options", "optional": true } ] } ], "desc": "For example:
\nconst Transform = require('stream').Transform;\n\nclass MyTransform extends Transform {\n constructor(options) {\n super(options);\n }\n}\nOr, when using pre-ES6 style constructors:
\nconst Transform = require('stream').Transform;\nconst util = require('util');\n\nfunction MyTransform(options) {\n if (!(this instanceof MyTransform))\n return new MyTransform(options);\n Transform.call(this, options);\n}\nutil.inherits(MyTransform, Transform);\nOr, using the Simplified Constructor approach:
\nconst Transform = require('stream').Transform;\n\nconst myTransform = new Transform({\n transform(chunk, encoding, callback) {\n // ...\n }\n});\nNote: This function MUST NOT be called by application code directly. It\nshould be implemented by child classes, and called only by the internal Readable\nclass methods only.
\nIn some cases, a transform operation may need to emit an additional bit of\ndata at the end of the stream. For example, a zlib compression stream will\nstore an amount of internal state used to optimally compress the output. When\nthe stream ends, however, that additional data needs to be flushed so that the\ncompressed data will be complete.
Custom [Transform][] implementations may implement the transform._flush()\nmethod. This will be called when there is no more written data to be consumed,\nbut before the ['end'][] event is emitted signaling the end of the\n[Readable][] stream.
Within the transform._flush() implementation, the readable.push() method\nmay be called zero or more times, as appropriate. The callback function must\nbe called when the flush operation is complete.
The transform._flush() method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.
Note: This function MUST NOT be called by application code directly. It\nshould be implemented by child classes, and called only by the internal Readable\nclass methods only.
\nAll Transform stream implementations must provide a _transform()\nmethod to accept input and produce output. The transform._transform()\nimplementation handles the bytes being written, computes an output, then passes\nthat output off to the readable portion using the readable.push() method.
The transform.push() method may be called zero or more times to generate\noutput from a single input chunk, depending on how much is to be output\nas a result of the chunk.
It is possible that no output is generated from any given chunk of input data.
\nThe callback function must be called only when the current chunk is completely\nconsumed. The first argument passed to the callback must be an Error object\nif an error occurred while processing the input or null otherwise. If a second\nargument is passed to the callback, it will be forwarded on to the\nreadable.push() method. In other words the following are equivalent:
transform.prototype._transform = function (data, encoding, callback) {\n this.push(data);\n callback();\n};\n\ntransform.prototype._transform = function (data, encoding, callback) {\n callback(null, data);\n};\nThe transform._transform() method is prefixed with an underscore because it\nis internal to the class that defines it, and should never be called directly by\nuser programs.
The ['finish'][] and ['end'][] events are from the stream.Writable\nand stream.Readable classes, respectively. The 'finish' event is emitted\nafter [stream.end()][stream-end] is called and all chunks have been processed\nby [stream._transform()][stream-_transform]. The 'end' event is emitted\nafter all data has been output, which occurs after the callback in\n[transform._flush()][stream-_flush] has been called.
The stream.PassThrough class is a trivial implementation of a [Transform][]\nstream that simply passes the input bytes across to the output. Its purpose is\nprimarily for examples and testing, but there are some use cases where\nstream.PassThrough is useful as a building block for novel sorts of streams.
In versions of Node.js prior to v0.10, the Readable stream interface was\nsimpler, but also less powerful and less useful.
\nstream.read()][stream-read] method,\n['data'][] events would begin emitting immediately. Applications that\nwould need to perform some amount of work to decide how to handle data\nwere required to store read data into buffers so the data would not be lost.stream.pause()][stream-pause] method was advisory, rather than\nguaranteed. This meant that it was still necessary to be prepared to receive\n['data'][] events even when the stream was in a paused state.In Node.js v0.10, the [Readable][] class was added. For backwards compatibility\nwith older Node.js programs, Readable streams switch into "flowing mode" when a\n['data'][] event handler is added, or when the\n[stream.resume()][stream-resume] method is called. The effect is that, even\nwhen not using the new [stream.read()][stream-read] method and\n['readable'][] event, it is no longer necessary to worry about losing\n['data'][] chunks.
While most applications will continue to function normally, this introduces an\nedge case in the following conditions:
\n'data'][] event listener is added.stream.resume()][stream-resume] method is never called.For example, consider the following code:
\n// WARNING! BROKEN!\nnet.createServer((socket) => {\n\n // we add an 'end' method, but never consume the data\n socket.on('end', () => {\n // It will never get here.\n socket.end('The message was received but was not processed.\\n');\n });\n\n}).listen(1337);\nIn versions of Node.js prior to v0.10, the incoming message data would be\nsimply discarded. However, in Node.js v0.10 and beyond, the socket remains\npaused forever.
\nThe workaround in this situation is to call the\n[stream.resume()][stream-resume] method to begin the flow of data:
// Workaround\nnet.createServer((socket) => {\n\n socket.on('end', () => {\n socket.end('The message was received but was not processed.\\n');\n });\n\n // start the flow of data, discarding it.\n socket.resume();\n\n}).listen(1337);\nIn addition to new Readable streams switching into flowing mode,\npre-v0.10 style streams can be wrapped in a Readable class using the\n[readable.wrap()][stream.wrap()] method.
There are some cases where it is necessary to trigger a refresh of the\nunderlying readable stream mechanisms, without actually consuming any\ndata. In such cases, it is possible to call readable.read(0), which will\nalways return null.
If the internal read buffer is below the highWaterMark, and the\nstream is not currently reading, then calling stream.read(0) will trigger\na low-level [stream._read()][stream-_read] call.
While most applications will almost never need to do this, there are\nsituations within Node.js where this is done, particularly in the\nReadable stream class internals.
\n", "type": "misc", "displayName": "`readable.read(0)`" }, { "textRaw": "`readable.push('')`", "name": "`readable.push('')`", "desc": "Use of readable.push('') is not recommended.
Pushing a zero-byte string or Buffer to a stream that is not in object mode\nhas an interesting side effect. Because it is a call to\n[readable.push()][stream-push], the call will end the reading process.\nHowever, because the argument is an empty string, no data is added to the\nreadable buffer so there is nothing for a user to consume.