Emitting and listening for events in Node.js

Introduction

Events let parts of your program talk to each other. You send out a signal (emit) and other parts can hear it (listen) and react.

You want to run some code when a file finishes loading.

You want to update the screen when new data arrives.

You want to log a message when a user logs in.

You want to handle errors in a central place.

You want to trigger multiple actions after a button click.

Syntax

Node.js

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// Listen for an event
myEmitter.on('eventName', (data) => {
  // code to run when event happens
});

// Emit the event
myEmitter.emit('eventName', eventData);

Use on to listen for events.

Use emit to send out events.

Examples

This example listens for a 'ping' event and prints a message when it happens.

Node.js

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// Example 1: Simple event with no data
myEmitter.on('ping', () => {
  console.log('Ping received');
});
myEmitter.emit('ping');

This example sends a name with the event and the listener uses it.

Node.js

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// Example 2: Event with data
myEmitter.on('greet', (name) => {
  console.log(`Hello, ${name}!`);
});
myEmitter.emit('greet', 'Alice');

Shows that many listeners can respond to the same event.

Node.js

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// Example 3: Multiple listeners for one event
myEmitter.on('alert', () => {
  console.log('Alert listener 1');
});
myEmitter.on('alert', () => {
  console.log('Alert listener 2');
});
myEmitter.emit('alert');

If no one listens, emitting does nothing and causes no error.

Node.js

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// Example 4: No listeners for event
myEmitter.emit('noListener');

Sample Program

This program shows how to listen for an event and emit it with data. It prints messages before and after emitting to show the order.

Node.js

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// Print before emitting
console.log('Before emitting event');

// Listen for 'dataReceived' event
myEmitter.on('dataReceived', (data) => {
  console.log(`Data received: ${data}`);
});

// Emit the event with some data
myEmitter.emit('dataReceived', 'Hello World');

// Print after emitting
console.log('After emitting event');

Important Notes

Emitting an event runs all listeners in the order they were added.

Listeners run synchronously by default, so code after emit runs after listeners finish.

Common mistake: forgetting to add a listener before emitting the event.

Use events to decouple parts of your program so they don't need to know about each other directly.

Summary

Events let parts of your program communicate by sending and receiving signals.

Use on to listen and emit to send events.

Listeners run in order and receive any data sent with the event.

Practice

1. What does the emit method do in Node.js event handling?

easy

A. It sends or triggers an event to notify listeners.

B. It listens for an event to occur.

C. It removes an event listener.

D. It creates a new event emitter object.

Solution

1. Step 1: Understand the role of emit

   The emit method is used to send or trigger an event in Node.js.

2. Step 2: Differentiate from other methods

   The on method listens for events, while emit triggers them.

3. Final Answer:

   It sends or triggers an event to notify listeners. -> Option A

4. Quick Check:

   emit triggers event = B [OK]

Hint: Remember: emit sends, on listens [OK]

Common Mistakes:

• Confusing emit with on (listening vs sending)
• Thinking emit creates event emitters
• Assuming emit removes listeners

2. Which of the following is the correct syntax to listen for an event named data using an EventEmitter instance emitter?

easy

A. emitter.emit('data', callback);

B. emitter.listen('data', callback);

C. emitter.addListener('callback', 'data');

D. emitter.on('data', callback);

Solution

1. Step 1: Identify the method to listen for events

   The correct method to listen for events is on, used as emitter.on(eventName, callback).

2. Step 2: Check the syntax correctness

   emitter.on('data', callback); correctly listens for the 'data' event.

3. Final Answer:

   emitter.on('data', callback); -> Option D

4. Quick Check:

   Listening uses on = C [OK]

Hint: Use on(event, callback) to listen [OK]

Common Mistakes:

• Using emit instead of on to listen
• Using non-existent listen method
• Swapping event name and callback parameters

3. What will be the output of the following code?

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('greet', (name) => {
  console.log(`Hello, ${name}!`);
});
emitter.emit('greet', 'Alice');

medium

A. Hello, Alice!

B. greet Alice

C. Error: No listener for greet

D. undefined

Solution

1. Step 1: Understand event registration

   The code registers a listener for the 'greet' event that logs a greeting with the passed name.

2. Step 2: Analyze event emission

   When emit('greet', 'Alice') runs, it calls the listener with 'Alice', printing "Hello, Alice!".

3. Final Answer:

   Hello, Alice! -> Option A

4. Quick Check:

   emit calls listener with data = A [OK]

Hint: emit triggers listener with arguments [OK]

Common Mistakes:

• Expecting event name to print
• Thinking emit returns a value
• Missing that listener receives emitted data

4. Identify the error in this code snippet:

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.emit('start');
emitter.on('start', () => {
  console.log('Started');
});

medium

A. The listener callback syntax is incorrect.

B. The event name 'start' is invalid.

C. emit is called before the listener is registered, so listener won't run.

D. EventEmitter cannot emit events without arguments.

Solution

1. Step 1: Check order of emit and listener registration

   The code calls emit('start') before registering the listener with on('start').

2. Step 2: Understand event flow

   Since no listener exists when emit runs, the callback never executes, so 'Started' is not printed.

3. Final Answer:

   emit is called before the listener is registered, so listener won't run. -> Option C

4. Quick Check:

   Listener must be registered before emit = A [OK]

Hint: Register listeners before emitting events [OK]

Common Mistakes:

• Assuming emit queues events for future listeners
• Thinking event names must be special strings
• Believing emit requires arguments always

5. You want to emit an event update multiple times with different data, but only the first listener should respond once. Which method should you use to register the listener?

hard

A. emitter.on('update', listener);

B. emitter.once('update', listener);

C. emitter.emit('update', listener);

D. emitter.addListener('update', listener);

Solution

1. Step 1: Understand listener methods

   on registers a listener that runs every time the event is emitted; once registers a listener that runs only once.

2. Step 2: Apply to the problem

   Since only the first event should trigger the listener, once is the correct method.

3. Final Answer:

   emitter.once('update', listener); -> Option B

4. Quick Check:

   Use once() for single-run listener = D [OK]

Hint: Use once() for one-time event listeners [OK]

Common Mistakes:

• Using on() which triggers every time
• Confusing emit() as listener registration
• Thinking addListener differs from on() in behavior