Worker interface.
+Optional Readonly disconnectCluster worker disconnect.
-Optional Readonly idCluster worker id.
-Optional Readonly killCluster worker kill.
-Optional signal: stringReadonly onRegisters an event handler.
+unref? +Optional Readonly disconnectCluster worker disconnect.
+Cluster worker disconnect.
+Optional Readonly idCluster worker id.
+Optional Readonly killCluster worker kill.
+Cluster worker kill.
+Optional signal: stringReadonly onRegisters an event handler.
+Registers an event handler.
The event.
-The event handler.
-Readonly onceRegisters once an event handler.
+The event handler.
+The event.
+The event handler.
+Readonly onceRegisters once an event handler.
+Registers once an event handler.
The event.
-The event handler.
-Optional Readonly terminateStop all JavaScript execution in the worker thread as soon as possible. +
The event handler.
+The event.
+The event handler.
+Optional Readonly terminateStop all JavaScript execution in the worker thread as soon as possible.
Returns a Promise for the exit code that is fulfilled when the 'exit' event is emitted.
Optional Readonly threadWorker thread worker id.
-Generated using TypeDoc
Stop all JavaScript execution in the worker thread as soon as possible.
+Returns a Promise for the exit code that is fulfilled when the 'exit' event is emitted.
Optional Readonly threadWorker thread worker id.
+Optional Readonly unrefCalling unref() on a worker allows the thread to exit if this is the only
+active handle in the event system. If the worker is already unref()ed callingunref() again has no effect.
Calling unref() on a worker allows the thread to exit if this is the only
+active handle in the event system. If the worker is already unref()ed callingunref() again has no effect.
v10.5.0
+v10.5.0
+Optional [captureSynchronously calls each of the listeners registered for the event namedeventName, in the order they were registered, passing the supplied arguments
+to each.
Returns true if the event had listeners, false otherwise.
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
+Rest ...args: any[]v0.1.26
+Returns an array listing the events for which the emitter has registered
+listeners. The values in the array are strings or Symbols.
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 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.
The name of the event being listened for
+Optional listener: FunctionThe event handler function
+v3.2.0
+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
+Adds the listener function to the beginning of the listeners array for the
+event named eventName. No checks are made to see if the listener has
+already been added. Multiple calls passing the same combination of eventNameand listener will result in the listener being added, and called, multiple
+times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
The name of the event.
+The callback function
+Rest ...args: any[]v6.0.0
+Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this
+listener is removed, and then invoked.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
+Returns a reference to the EventEmitter, so that calls can be chained.
The name of the event.
+The callback function
+Rest ...args: any[]v6.0.0
+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
+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.
Optional event: string | symbolv0.1.26
+Removes the specified listener from the listener array for the event namedeventName.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
+removeListener() will remove, at most, one instance of a listener from the
+listener array. If any single listener has been added multiple times to the
+listener array for the specified eventName, then removeListener() must be
+called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
+time of emitting are called in order. This implies that anyremoveListener() or removeAllListeners() calls after emitting and before the last listener finishes execution
+will not remove them fromemit() in progress. Subsequent events behave as expected.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
+Because listeners are managed using an internal array, calling this will
+change the position indices of any listener registered after the listener
+being removed. This will not impact the order in which listeners are called,
+but it means that any copies of the listener array as returned by
+the emitter.listeners() method will need to be recreated.
When a single function has been added as a handler multiple times for a single
+event (as in the example below), removeListener() will remove the most
+recently added instance. In the example the once('ping')listener is removed:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
+Returns a reference to the EventEmitter, so that calls can be chained.
Rest ...args: any[]v0.1.26
+By default EventEmitters 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
+Generated using TypeDoc
Worker interface.
-