Custom event emitter classes in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this custom event emitter code?

Consider this Node.js custom event emitter class. What will be printed when the code runs?

Node.js

import { EventEmitter } from 'node:events';

class MyEmitter extends EventEmitter {
  constructor() {
    super();
    this.on('ping', () => {
      console.log('pong');
    });
  }
}

const emitter = new MyEmitter();
emitter.emit('ping');

A ping

B undefined

C pong

D Error: event not handled

💡 Hint

Think about what happens when the 'ping' event is emitted and how the listener responds.

The 'ping' event triggers the listener which logs 'pong' to the console.

📝 Syntax

intermediate

Which option correctly adds a listener to a custom event emitter?

Given a custom event emitter instance, which code snippet correctly adds a listener for the 'data' event?

Node.js

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();

A emitter.on('data', () => console.log('received'));

B emitter.addListener('data', console.log('received'));

C emitter.listen('data', () => console.log('received'));

D emitter.on('data', console.log('received'));

💡 Hint

Remember the standard method to add event listeners in Node.js EventEmitter.

The correct method is on with a callback function. Option A uses this correctly.

🔧 Debug

advanced

Why does this custom event emitter code throw an error?

Examine the code below. Why does it throw an error when emitting the 'start' event?

Node.js

import { EventEmitter } from 'node:events';

class MyEmitter extends EventEmitter {
  constructor() {
    super();
  }
}

const emitter = new MyEmitter();
emitter.emit('start');

A The constructor is missing a call to super(), causing an error.

B No listener is registered for 'start', so emit returns false but no error is thrown.

C The event name 'start' is invalid and causes an error.

D emit throws an error if no listeners exist for the event.

💡 Hint

Think about what happens when an event is emitted but no listeners are attached.

Emitting an event with no listeners returns false but does not throw an error.

❓ state_output

advanced

What is the value of count after emitting events?

What is the value of count after the code runs?

Node.js

import { EventEmitter } from 'node:events';

class Counter extends EventEmitter {
  constructor() {
    super();
    this.count = 0;
    this.on('increment', () => {
      this.count += 1;
    });
  }
}

const counter = new Counter();
counter.emit('increment');
counter.emit('increment');
counter.emit('increment');

const count = counter.count;

A 3

B 0

C undefined

D Error: count is not defined

💡 Hint

Each 'increment' event increases count by 1. How many times is it emitted?

The 'increment' event is emitted 3 times, so count increases from 0 to 3.

🧠 Conceptual

expert

Which option best explains why custom event emitters improve Node.js apps?

Why do developers use custom event emitter classes in Node.js applications?

A They enforce strict type checking on event names and listener arguments.

B They automatically optimize CPU usage by managing event loops internally.

C They replace the need for callbacks and promises entirely in asynchronous code.

D They allow decoupling of code by letting parts communicate via events without direct calls.

💡 Hint

Think about how events help different parts of an app work together without tight connections.

Custom event emitters let different parts of an app communicate by sending and listening for events, reducing direct dependencies.

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