Readable | ReadableStream | AsyncIterator<any, any, undefined>

Readable | ReadableStream | AsyncIterator<any, any, undefined>

Readable | ReadableStream | AsyncIterator<any, any, undefined>

Readable | ReadableStream | AsyncIterator<any, any, undefined>

Readable | ReadableStream | AsyncIterator<any, any, undefined>

ReadableStream | WritableStream | ReadWriteStream

FinishedOptions

A

B

PipelineOptions

A

T1

B

PipelineOptions

A

T1

T2

B

PipelineOptions

A

T1

T2

T3

B

PipelineOptions

A

T1

T2

T3

T4

B

PipelineOptions

readonly ReadableStream | WritableStream | ReadWriteStream []

PipelineOptions

ReadableStream

WritableStream | ReadWriteStream

WritableStream | ReadWriteStream | PipelineOptions []

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.

Returns true if the event had listeners, false otherwise.

`js
const EventEmitter = require('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
`

`js
const EventEmitter = require('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) ]
`

`js
server.on('connection', stream => {
console.log('someone connected!')
})
console.log(util.inspect(server.listeners('connection')))
// Prints: [ [Function] ]
`

`js
server.on('connection', stream => {
console.log('someone connected!')
})
`

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. Theemitter.prependListener() method can be used as an alternative to add the
event listener to the beginning of the listeners array.

`js
const myEE = new EventEmitter()
myEE.on('foo', () => console.log('a'))
myEE.prependListener('foo', () => console.log('b'))
myEE.emit('foo')
// Prints:
// b
// a
`

`js
server.once('connection', stream => {
console.log('Ah, we have our first user!')
})
`

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. Theemitter.prependOnceListener() method can be used as an alternative to add the
event listener to the beginning of the listeners array.

`js
const myEE = new EventEmitter()
myEE.once('foo', () => console.log('a'))
myEE.prependOnceListener('foo', () => console.log('b'))
myEE.emit('foo')
// Prints:
// b
// a
`

`js
server.prependListener('connection', stream => {
console.log('someone connected!')
})
`

Returns a reference to the EventEmitter, so that calls can be chained.

`js
server.prependOnceListener('connection', stream => {
console.log('Ah, we have our first user!')
})
`

Returns a reference to the EventEmitter, so that calls can be chained.

`js
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')
`

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.

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

`js
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:

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

Returns a reference to the EventEmitter, so that calls can be chained.

For EventEmitters this behaves exactly the same as calling .listeners on
the emitter.

For EventTargets this is the only way to get the event listeners for the
event target. This is useful for debugging and diagnostic purposes.

`js
const { getEventListeners, EventEmitter } = require('events')

{
const ee = new EventEmitter()
const listener = () => console.log('Events are fun')
ee.on('foo', listener)
getEventListeners(ee, 'foo') // [listener]
}
{
const et = new EventTarget()
const listener = () => console.log('Events are fun')
et.addEventListener('foo', listener)
getEventListeners(et, 'foo') // [listener]
}
`

`js
const { EventEmitter, listenerCount } = require('events')
const myEmitter = new EventEmitter()
myEmitter.on('event', () => {})
myEmitter.on('event', () => {})
console.log(listenerCount(myEmitter, 'event'))
// Prints: 2
`

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

`js
const { on, EventEmitter } = require('events');
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());
``

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.

`js
const { once, EventEmitter } = require('events')

async function run() {
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.log('error happened', err)
}
}

run()
`

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:

`js
const { EventEmitter, once } = require('events')

const ee = new EventEmitter()

once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch(err => console.log('error', err.message))

ee.emit('error', new Error('boom'))

// Prints: ok boom
`

An AbortSignal can be used to cancel waiting for the event:

`js
const { EventEmitter, once } = require('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!
`

`js
EventEmitter.setMaxListeners(20)
// Equivalent to
EventEmitter.defaultMaxListeners = 20

const eventTarget = new EventTarget()
// Only way to increase limit for EventTarget instances
// as these doesn't expose its own setMaxListeners method
EventEmitter.setMaxListeners(20, eventTarget)
`

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.

addListener(event, cb)  =>

Server<T>

addListener(event, cb)  =>

Server<T>

addListener(event, cb)  =>

Server<T>

addListener(event, cb)  =>

Server<T>

addListener(event, listener)  =>

Server<T>

address()  =>

string | AddressInfo