# The Node Event emitter

> Learn how to work with custom events in Node.js using the EventEmitter class from the events module, with on, emit, once, and removeListener methods.

Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2018-08-19 | Updated: 2020-07-04 | Topics: [Node.js](https://flaviocopes.com/tags/node/) | Canonical: https://flaviocopes.com/node-event-emitter/

If you worked with [JavaScript](https://flaviocopes.com/javascript/) in the browser, you know how much of the interaction of the user is handled through events: mouse clicks, keyboard button presses, reacting to mouse movements, and so on.

On the backend side, Node offers us the option to build a similar system using the [`events` module](https://nodejs.org/api/events.html).

This module, in particular, offers the `EventEmitter` class, which we'll use to handle our events.

You initialize an EventEmitter object using this syntax:

```js
const EventEmitter = require('events')
const eventEmitter = new EventEmitter()
```

This object exposes, among many others, the `on` and `emit` methods.

- `emit` is used to trigger an event
- `on` is used to add a callback function that's going to be executed when the event is triggered

## Emit and listen for events

For example, let's create a `start` event, and as a matter of providing a sample, we react to that by just logging to the console:

```js
eventEmitter.on('start', () => {
  console.log('started')
})
```

When we run

```js
eventEmitter.emit('start')
```

the event handler function is triggered, and we get the console log.

`addListener()` is an alias for `on()`, in case you see that used.

## Passing arguments to the event

You can pass arguments to the event handler by passing them as additional arguments to `emit()`:

```js
eventEmitter.on('start', (number) => {
  console.log(`started ${number}`)
})

eventEmitter.emit('start', 23)
```

Multiple arguments:

```js
eventEmitter.on('start', (start, end) => {
  console.log(`started from ${start} to ${end}`)
})

eventEmitter.emit('start', 1, 100)
```

## Listen for an event just once

The EventEmitter object also exposes the `once()` method, which you can use to create a one-time event listener.

Once that event is fired, the listener stops listening.

Example:

```js
eventEmitter.once('start', () => {
  console.log(`started!`)
})

eventEmitter.emit('start')
eventEmitter.emit('start') //not going to fire
```

## Removing an event listener

Once you create an event listener, you can remove it using the `removeListener()` method.

To do so, we must first have a reference to the callback function of `on`.

In this example:

```js
eventEmitter.on('start', () => {
  console.log('started')
})
```

Extract the callback:

```js
const callback = () => {
  console.log('started')
}

eventEmitter.on('start', callback)
```

So that later you can call 

```js
eventEmitter.removeListener('start', callback)
```

You can also remove all listeners at once on an event, using:

```js
eventEmitter.removeAllListeners('start')
```

## Getting the events registered

The `eventNames()` method, called on an EventEmitter object instance, returns an array of strings that represent the events registered on the current EventListener:

```js
const EventEmitter = require('events')
const eventEmitter = new EventEmitter()

eventEmitter.on('start', () => {
  console.log('started')
})

eventEmitter.eventNames() // [ 'start' ]
```

`listenerCount()` returns the count of listeners of the event passed as parameter:

```js
eventEmitter.listenerCount('start') //1
```

## Adding more listeners before/after other ones

If you have multiple listeners, the order of them might be important.

An EventEmitter object instance offers some methods to work with order.

## emitter.prependListener()

When you add a listener using `on` or `addListener`, it's added last in the queue of listeners, and called last. Using `prependListener` it's added, and called, before other listeners.

## emitter.prependOnceListener()

When you add a listener using `once`, it's added last in the queue of listeners, and called last. Using `prependOnceListener` it's added, and called, before other listeners.