Create an instance of NoFilter.
Optional
input: string | Buffer | NoFilterOptionsSource data.
Optional
inputEncoding: BufferEncoding | NoFilterOptionsEncoding name for input, ignored if input is not a String.
Optional
options: NoFilterOptions = {}Other options.
If false
then the stream will automatically end the writable side when the
readable side ends. Set initially by the allowHalfOpen
constructor option,
which defaults to true
.
This can be changed manually to change the half-open behavior of an existingDuplex
stream instance, but must be changed before the 'end'
event is
emitted.
v0.9.4
Readonly
closedIs true
after readable.destroy()
has been called.
v8.0.0
Readonly
erroredIs true
if it is safe to call readable.read()
, which means
the stream has not been destroyed or emitted 'error'
or 'end'
.
v11.4.0
Readonly
Experimental
readableReturns whether the stream was destroyed or errored before emitting 'end'
.
v16.8.0
Readonly
Experimental
readableReturns whether 'data'
has been emitted.
v16.7.0, v14.18.0
Readonly
readableGetter for the property encoding
of a given Readable
stream. The encoding
property can be set using the readable.setEncoding()
method.
v12.7.0
Readonly
readableBecomes true
when 'end'
event is emitted.
v12.9.0
Readonly
readableThis property reflects the current state of a Readable
stream as described
in the Three states
section.
v9.4.0
Readonly
readableReturns the value of highWaterMark
passed when creating this Readable
.
v9.3.0
Readonly
readableThis property contains the number of bytes (or objects) in the queue
ready to be read. The value provides introspection data regarding
the status of the highWaterMark
.
v9.4.0
Readonly
readableGetter for the property objectMode
of a given Readable
stream.
v12.3.0
Readonly
writableReadonly
writableReadonly
writableReadonly
writableReadonly
writableReadonly
writableReadonly
writableReadonly
writableStatic
Readonly
captureValue: Symbol.for('nodejs.rejection')
See how to write a custom rejection handler
.
v13.4.0, v12.16.0
Static
captureValue: boolean
Change the default captureRejections
option on all new EventEmitter
objects.
v13.4.0, v12.16.0
Static
defaultBy default, a maximum of 10
listeners can be registered for any single
event. This limit can be changed for individual EventEmitter
instances
using the emitter.setMaxListeners(n)
method. To change the default
for allEventEmitter
instances, the events.defaultMaxListeners
property can be used. If this value is not a positive number, a RangeError
is thrown.
Take caution when setting the events.defaultMaxListeners
because the
change affects allEventEmitter
instances, including those created before
the change is made. However, calling emitter.setMaxListeners(n)
still has
precedence over events.defaultMaxListeners
.
This is not a hard limit. The EventEmitter
instance will allow
more listeners to be added but will output a trace warning to stderr indicating
that a "possible EventEmitter memory leak" has been detected. For any singleEventEmitter
, the emitter.getMaxListeners()
and emitter.setMaxListeners()
methods can be used to
temporarily avoid this warning:
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
// do stuff
emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});
The --trace-warnings
command-line flag can be used to display the
stack trace for such warnings.
The emitted warning can be inspected with process.on('warning')
and will
have the additional emitter
, type
, and count
properties, referring to
the event emitter instance, the event's name and the number of attached
listeners, respectively.
Its name
property is set to 'MaxListenersExceededWarning'
.
v0.11.2
Static
Readonly
errorThis symbol shall be used to install a listener for only monitoring 'error'
events. Listeners installed using this symbol are called before the regular'error'
listeners are called.
Installing a listener using this symbol does not change the behavior once an'error'
event is emitted. Therefore, the process will still crash if no
regular 'error'
listener is installed.
v13.6.0, v12.17.0
Current readable length, in bytes.
Length of the contents.
Optional
_constructOptional
_writevEvent emitter The defined events on documents including:
Rest
...args: any[]Returns a number indicating whether this comes before or after or is the same as the other NoFilter in sort order.
Arguments must be NoFilters.
The other object to compare.
Destroy the stream. Optionally emit an 'error'
event, and emit a 'close'
event (unless emitClose
is set to false
). After this call, the readable
stream will release any internal resources and subsequent calls to push()
will be ignored.
Once destroy()
has been called any further calls will be a no-op and no
further errors except from _destroy()
may be emitted as 'error'
.
Implementors should not override this method, but instead implement readable._destroy()
.
v8.0.0
Optional
error: ErrorError which will be passed as payload in 'error'
event
Rest
...args: any[]Optional
cb: (() => void)Optional
cb: (() => void)Optional
encoding: BufferEncodingOptional
cb: (() => void)Do these NoFilter's contain the same bytes? Doesn't work if either is in object mode.
Other NoFilter to compare against.
Equal?
Returns an array listing the events for which the emitter has registered
listeners. The values in the array are strings or Symbol
s.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
v6.0.0
Returns the current max listener value for the EventEmitter
which is either
set by emitter.setMaxListeners(n)
or defaults to defaultMaxListeners.
v1.0.0
The readable.isPaused()
method returns the current operating state of theReadable
. This is used primarily by the mechanism that underlies thereadable.pipe()
method. In most
typical cases, there will be no reason to
use this method directly.
const readable = new stream.Readable();
readable.isPaused(); // === false
readable.pause();
readable.isPaused(); // === true
readable.resume();
readable.isPaused(); // === false
v0.11.14
Returns the number of listeners listening for the event named eventName
.
If listener
is provided, it will return how many times the listener is found
in the list of the listeners of the event.
v3.2.0
The name of the event being listened for
Optional
listener: FunctionThe event handler function
Returns a copy of the array of listeners for the event named eventName
.
server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
v0.1.26
Rest
...args: any[]Rest
...args: any[]The readable.pause()
method will cause a stream in flowing mode to stop
emitting 'data'
events, switching out of flowing mode. Any data that
becomes available will remain in the internal buffer.
const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
console.log(`Received ${chunk.length} bytes of data.`);
readable.pause();
console.log('There will be no additional data for 1 second.');
setTimeout(() => {
console.log('Now data will start flowing again.');
readable.resume();
}, 1000);
});
The readable.pause()
method has no effect if there is a 'readable'
event listener.
v0.9.4
Rest
...args: any[]Rest
...args: any[]Return a promise fulfilled with the full contents, after the 'finish' event fires. Errors on the stream cause the promise to be rejected.
Optional
cb: FunctionFinished/error callback used in addition to the promise.
Fulfilled when complete.
Returns a copy of the array of listeners for the event named eventName
,
including any wrappers (such as those created by .once()
).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
v9.4.0
Pulls some data out of the internal buffer and returns it. If there is no data available, then it will return null.
If you pass in a size argument, then it will return that many bytes. If size bytes are not available, then it will return null, unless we've ended, in which case it will return the data remaining in the buffer.
If you do not specify a size argument, then it will return all the data in the internal buffer.
Error If readError is true and there was underflow.
NoFilter#read When read from.
Optional
size: numberNumber of bytes to read.
If no data or not enough data, null. If decoding output a string, otherwise a Buffer.
Read the full number of bytes asked for, no matter how long it takes. Fail if an error occurs in the meantime, or if the stream finishes before enough data is available.
Note: This function won't work fully correctly if you are using stream-browserify (for example, on the Web).
The number of bytes to read.
A promise for the data read.
Removes all listeners, or those of the specified eventName
.
It is bad practice to remove listeners added elsewhere in the code,
particularly when the EventEmitter
instance was created by some other
component or module (e.g. sockets or file streams).
Returns a reference to the EventEmitter
, so that calls can be chained.
v0.1.26
Optional
event: string | symbolRest
...args: any[]The readable.resume()
method causes an explicitly paused Readable
stream to
resume emitting 'data'
events, switching the stream into flowing mode.
The readable.resume()
method can be used to fully consume the data from a
stream without actually processing any of that data:
getReadableStreamSomehow()
.resume()
.on('end', () => {
console.log('Reached the end, but did not read anything.');
});
The readable.resume()
method has no effect if there is a 'readable'
event listener.
v0.9.4
The readable.setEncoding()
method sets the character encoding for
data read from the Readable
stream.
By default, no encoding is assigned and stream data will be returned asBuffer
objects. Setting an encoding causes the stream data
to be returned as strings of the specified encoding rather than as Buffer
objects. For instance, calling readable.setEncoding('utf8')
will cause the
output data to be interpreted as UTF-8 data, and passed as strings. Callingreadable.setEncoding('hex')
will cause the data to be encoded in hexadecimal
string format.
The Readable
stream will properly handle multi-byte characters delivered
through the stream that would otherwise become improperly decoded if simply
pulled from the stream as Buffer
objects.
const readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', (chunk) => {
assert.equal(typeof chunk, 'string');
console.log('Got %d characters of string data:', chunk.length);
});
v0.9.4
The encoding to use.
By default EventEmitter
s will print a warning if more than 10
listeners are
added for a particular event. This is a useful default that helps finding
memory leaks. The emitter.setMaxListeners()
method allows the limit to be
modified for this specific EventEmitter
instance. The value can be set toInfinity
(or 0
) to indicate an unlimited number of listeners.
Returns a reference to the EventEmitter
, so that calls can be chained.
v0.3.5
Read bytes or objects without consuming them. Useful for diagnostics. Note: as a side-effect, concatenates multiple writes together into what looks like a single write, so that this concat doesn't have to happen multiple times when you're futzing with the same NoFilter.
Optional
start: numberBeginning offset.
Optional
end: numberEnding offset.
If in object mode, an array of objects. Otherwise, concatenated array of contents.
Return an object compatible with Buffer's toJSON implementation, so that round-tripping will produce a Buffer.
output for 'foo', not in object mode
({
type: 'Buffer',
data: [102, 111, 111],
})
If in object mode, the objects. Otherwise, JSON text.
Decodes and returns a string from buffer data encoded using the specified character set encoding. If encoding is undefined or null, then encoding defaults to 'utf8'. The start and end parameters default to 0 and NoFilter.length when undefined.
Optional
encoding: BufferEncodingWhich to use for decoding?
Optional
start: numberStart offset.
Optional
end: numberEnd offset.
String version of the contents.
The readable.unpipe()
method detaches a Writable
stream previously attached
using the 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
the method does nothing.
const fs = require('node:fs');
const readable = getReadableStreamSomehow();
const writable = fs.createWriteStream('file.txt');
// All the data from readable goes into 'file.txt',
// but only for the first second.
readable.pipe(writable);
setTimeout(() => {
console.log('Stop writing to file.txt.');
readable.unpipe(writable);
console.log('Manually close the file stream.');
writable.end();
}, 1000);
v0.9.4
Optional
destination: WritableStreamOptional specific stream to unpipe
Passing chunk
as null
signals the end of the stream (EOF) and behaves the
same as readable.push(null)
, after which no more data can be written. The EOF
signal is put at the end of the buffer and any buffered data will still be
flushed.
The readable.unshift()
method pushes a chunk of data back into the internal
buffer. This is useful in certain situations where a stream is being consumed by
code that needs to "un-consume" some amount of data that it has optimistically
pulled out of the source, so that the data can be passed on to some other party.
The stream.unshift(chunk)
method cannot be called after the 'end'
event
has been emitted or a runtime error will be thrown.
Developers using stream.unshift()
often should consider switching to
use of a Transform
stream instead. See the API for stream implementers
section for more information.
// Pull off a header delimited by \n\n.
// Use unshift() if we get too much.
// Call the callback with (error, header, stream).
const { StringDecoder } = require('node:string_decoder');
function parseHeader(stream, callback) {
stream.on('error', callback);
stream.on('readable', onReadable);
const decoder = new StringDecoder('utf8');
let header = '';
function onReadable() {
let chunk;
while (null !== (chunk = stream.read())) {
const str = decoder.write(chunk);
if (str.includes('\n\n')) {
// Found the header boundary.
const split = str.split(/\n\n/);
header += split.shift();
const remaining = split.join('\n\n');
const buf = Buffer.from(remaining, 'utf8');
stream.removeListener('error', callback);
// Remove the 'readable' listener before unshifting.
stream.removeListener('readable', onReadable);
if (buf.length)
stream.unshift(buf);
// Now the body of the message can be read from the stream.
callback(null, header, stream);
return;
}
// Still reading the header.
header += str;
}
}
}
Unlike push, stream.unshift(chunk)
will not
end the reading process by resetting the internal reading state of the stream.
This can cause unexpected results if readable.unshift()
is called during a
read (i.e. from within a _read implementation on a
custom stream). Following the call to readable.unshift()
with an immediate push will reset the reading state appropriately,
however it is best to simply avoid calling readable.unshift()
while in the
process of performing a read.
v0.9.11
Chunk of data to unshift onto the read queue. For streams not operating in object mode, chunk
must be a string, Buffer
, Uint8Array
, or null
. For object mode
streams, chunk
may be any JavaScript value.
Optional
encoding: BufferEncodingEncoding of string chunks. Must be a valid Buffer
encoding, such as 'utf8'
or 'ascii'
.
Prior to Node.js 0.10, streams did not implement the entire node:stream
module API as it is currently defined. (See Compatibility
for more
information.)
When using an older Node.js library that emits 'data'
events and has a pause method that is advisory only, thereadable.wrap()
method can be used to create a Readable
stream that uses
the old stream as its data source.
It will rarely be necessary to use readable.wrap()
but the method has been
provided as a convenience for interacting with older Node.js applications and
libraries.
const { OldReader } = require('./old-api-module.js');
const { Readable } = require('node:stream');
const oreader = new OldReader();
const myReader = new Readable().wrap(oreader);
myReader.on('readable', () => {
myReader.read(); // etc.
});
v0.9.4
An "old style" readable stream
Optional
encoding: BufferEncodingOptional
cb: ((error) => void)Optional
cb: ((error) => void)Static
compareStatic
concatReturns a buffer which is the result of concatenating all the NoFilters in the list together. If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
If length is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly if you already know it.
List not array of NoFilters.
Inputs. Must not be all either in object mode, or all not in object mode.
Optional
length: numberNumber of bytes or objects to read.
The concatenated values as an array if in object mode, otherwise a Buffer.
Static
fromA utility method for creating duplex streams.
Stream
converts writable stream into writable Duplex
and readable stream
to Duplex
.Blob
converts into readable Duplex
.string
converts into readable Duplex
.ArrayBuffer
converts into readable Duplex
.AsyncIterable
converts into a readable Duplex
. Cannot yield null
.AsyncGeneratorFunction
converts into a readable/writable transform
Duplex
. Must take a source AsyncIterable
as first parameter. Cannot yield
null
.AsyncFunction
converts into a writable Duplex
. Must return
either null
or undefined
Object ({ writable, readable })
converts readable
and
writable
into Stream
and then combines them into Duplex
where the
Duplex
will write to the writable
and read from the readable
.Promise
converts into readable Duplex
. Value null
is ignored.v16.8.0
Static
fromStatic
getReturns a copy of the array of listeners for the event named eventName
.
For EventEmitter
s this behaves exactly the same as calling .listeners
on
the emitter.
For EventTarget
s this is the only way to get the event listeners for the
event target. This is useful for debugging and diagnostic purposes.
import { getEventListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
const listener = () => console.log('Events are fun');
ee.on('foo', listener);
console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
const et = new EventTarget();
const listener = () => console.log('Events are fun');
et.addEventListener('foo', listener);
console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
v15.2.0, v14.17.0
Static
isStatic
isStatic
listenerA class method that returns the number of listeners for the given eventName
registered on the given emitter
.
import { EventEmitter, listenerCount } from 'node:events';
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
v0.9.12
Since v3.2.0 - Use listenerCount
instead.
The emitter to query
The event name
Static
onimport { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
Returns an AsyncIterator
that iterates eventName
events. It will throw
if the EventEmitter
emits 'error'
. It removes all listeners when
exiting the loop. The value
returned by each iteration is an array
composed of the emitted event arguments.
An AbortSignal
can be used to cancel waiting on events:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
v13.6.0, v12.16.0
The name of the event being listened for
Optional
options: StaticEventEmitterOptionsthat iterates eventName
events emitted by the emitter
Static
onceCreates a Promise
that is fulfilled when the EventEmitter
emits the given
event or that is rejected if the EventEmitter
emits 'error'
while waiting.
The Promise
will resolve with an array of all the arguments emitted to the
given event.
This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error'
event
semantics and does not listen to the 'error'
event.
import { once, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.error('error happened', err);
}
The special handling of the 'error'
event is only used when events.once()
is used to wait for another event. If events.once()
is used to wait for the
'error'
event itself, then it is treated as any other kind of event without
special handling:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.error('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
An AbortSignal
can be used to cancel waiting for the event:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
v11.13.0, v10.16.0
Optional
options: StaticEventEmitterOptionsOptional
options: StaticEventEmitterOptionsStatic
setimport { setMaxListeners, EventEmitter } from 'node:events';
const target = new EventTarget();
const emitter = new EventEmitter();
setMaxListeners(5, target, emitter);
v15.4.0
Optional
n: numberA non-negative number. The maximum number of listeners per EventTarget
event.
Rest
...eventTargets: (EventEmitter | _DOMEventTarget)[]Static
toGenerated using TypeDoc
NoFilter stream. Can be used to sink or source data to and from other node streams. Implemented as the "identity" Transform stream (hence the name), but allows for inspecting data that is in-flight.
Allows passing in source data (input, inputEncoding) at creation time. Source data can also be passed in the options object.
Example
source and sink