Custom event emitter classes in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a custom event emitter class in Node.js?

A custom event emitter class is a user-defined class that extends Node.js's built-in EventEmitter to create and manage custom events, allowing different parts of an app to communicate by emitting and listening to events.

beginner

How do you create a custom event emitter class in Node.js?

You create a custom event emitter class by importing { EventEmitter } from the 'events' module and extending it with your class. Then you can add methods that emit events using this.emit('eventName').

intermediate

Why use custom event emitter classes instead of plain callbacks?

Custom event emitters allow multiple listeners for the same event, better organization of event logic, and decoupling of code parts. Callbacks are limited to single responses and can get messy with many events.

beginner

What method do you use to listen for an event in a custom event emitter class?

You use the .on('eventName', callback) method to listen for an event. The callback runs whenever the event is emitted.

intermediate

How can you remove an event listener from a custom event emitter?

You can remove a listener using the .off('eventName', callback) method or .removeListener('eventName', callback). This stops the callback from running when the event fires.

Which Node.js module do you extend to create a custom event emitter class?

A http

B events

C fs

D stream

The 'events' module provides the EventEmitter class, which you extend to create custom event emitters.

What method do you call to emit an event in a custom event emitter?

A emit()

B on()

C listen()

D trigger()

The emit() method triggers an event and calls all listeners attached to that event.

How do you add a listener for an event named 'data'?

A on('data', callback)

B emit('data', callback)

C listen('data', callback)

D addListener('callback', 'data')

The on() method attaches a callback function to the 'data' event.

What happens if multiple listeners are attached to the same event?

A Only the last listener runs

B Only the first listener runs

C All listeners run in the order they were added

D Listeners run randomly

All listeners for an event run in the order they were added when the event is emitted.

Which method removes a specific listener from an event?

A addListener()

B emit()

C on()

D off()

The off() method removes a specific listener callback from an event.

Explain how to create and use a custom event emitter class in Node.js.

Think about how classes and events work together.

Describe the benefits of using custom event emitter classes over simple callbacks.

Consider how events help different parts of an app talk to each other.

Practice

1. What is the main purpose of creating a custom event emitter class in Node.js?

easy

A. To replace the need for functions and callbacks

B. To allow different parts of your program to communicate by sending and listening to events

C. To speed up the execution of synchronous code

D. To automatically handle HTTP requests

Solution

1. Step 1: Understand event emitters

   Event emitters let parts of a program send signals (events) and others listen and react to them.

2. Step 2: Purpose of custom event emitter classes

   Custom classes extend EventEmitter to organize and manage these events clearly.

3. Final Answer:

   To allow different parts of your program to communicate by sending and listening to events -> Option B

4. Quick Check:

   Event communication = C [OK]

Hint: Event emitters enable communication between code parts [OK]

Common Mistakes:

• Thinking event emitters speed up synchronous code
• Confusing event emitters with HTTP handling
• Believing event emitters replace all functions

2. Which of the following is the correct way to listen for an event named data in a custom event emitter instance myEmitter?

easy

A. myEmitter.on('data', callback)

B. myEmitter.emit('data', callback)

C. myEmitter.listen('data', callback)

D. myEmitter.trigger('data', callback)

Solution

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

   The on method is used to register a callback for an event.

2. Step 2: Check other options

   emit triggers events, listen and trigger are not valid EventEmitter methods.

3. Final Answer:

   myEmitter.on('data', callback) -> Option A

4. Quick Check:

   Listen with on() = A [OK]

Hint: Use on() to listen, emit() to send events [OK]

Common Mistakes:

• Using emit() to listen instead of on()
• Using non-existent methods like listen() or trigger()
• Confusing event names with method names

3. Consider this code snippet:

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

What will be printed when this code runs?

medium

A. greet Alice

B. Error: greet event not found

C. Hello, Alice!

D. undefined

Solution

1. Step 1: Understand event registration

   The on method registers a listener for 'greet' that prints a greeting with the name.

2. Step 2: Understand event emission

   The emit method triggers 'greet' with argument 'Alice', so the listener runs and prints the message.

3. Final Answer:

   Hello, Alice! -> Option C

4. Quick Check:

   Emit triggers listener output = B [OK]

Hint: emit() runs on() listeners with given arguments [OK]

Common Mistakes:

• Expecting event name or arguments to print directly
• Confusing emit() with on()
• Assuming error if no listener exists

4. What is wrong with this custom event emitter code?

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

medium

A. The event name 'start' is invalid

B. emit() cannot be called without arguments

C. You must call super() in the constructor of MyEmitter

D. The event listener is registered after the event is emitted, so it won't run

Solution

1. Step 1: Check event listener registration timing

   The listener for 'start' is added after the event is emitted, so it misses the event.

2. Step 2: Validate other options

   emit() can be called without arguments, super() is optional if no constructor, and 'start' is a valid event name.

3. Final Answer:

   The event listener is registered after the event is emitted, so it won't run -> Option D

4. Quick Check:

   Listener after emit = no output = D [OK]

Hint: Register listeners before emitting events [OK]

Common Mistakes:

• Calling emit() before on() listener
• Thinking emit() needs arguments always
• Assuming constructor must call super() if none defined

5. You want to create a custom event emitter class that counts how many times an event named ping is emitted. Which code correctly implements this behavior?

hard

A. class PingCounter extends EventEmitter {
constructor() {
super();
this.count = 0;
this.on('ping', () => this.count++);
}
}

B. class PingCounter extends EventEmitter {
constructor() {
this.count = 0;
this.on('ping', () => this.count++);
super();
}
}

C. class PingCounter extends EventEmitter {
count = 0;
on('ping', () => this.count++);
}

D. class PingCounter extends EventEmitter {
constructor() {
super();
this.count = 0;
this.emit('ping', () => this.count++);
}
}

Solution

1. Step 1: Proper constructor and super() call

   class PingCounter extends EventEmitter { constructor() { super(); this.count = 0; this.on('ping', () => this.count++); } } correctly calls super() first in constructor, required before using this.

2. Step 2: Correct event listener setup

   class PingCounter extends EventEmitter { constructor() { super(); this.count = 0; this.on('ping', () => this.count++); } } uses this.on('ping', () => this.count++) to increment count on each ping event.

3. Step 3: Check other options for errors

   class PingCounter extends EventEmitter { constructor() { this.count = 0; this.on('ping', () => this.count++); super(); } } calls this.on before super(), causing error. class PingCounter extends EventEmitter { count = 0; on('ping', () => this.count++); } has invalid syntax outside constructor. class PingCounter extends EventEmitter { constructor() { super(); this.count = 0; this.emit('ping', () => this.count++); } } wrongly uses emit instead of on.

4. Final Answer:

   class PingCounter extends EventEmitter { constructor() { super(); this.count = 0; this.on('ping', () => this.count++); } } -> Option A

5. Quick Check:

   super() first, then on() listener = A [OK]

Hint: Always call super() before using this in constructor [OK]

Common Mistakes:

• Calling this before super() in constructor
• Using emit() instead of on() to listen
• Placing on() calls outside constructor or methods