Events vs callbacks decision in Node.js - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

When to prefer events over callbacks?

In Node.js, which scenario best justifies using events instead of callbacks?

A When you want to execute a single asynchronous task and get its result once.

B When you need to handle multiple asynchronous actions that can happen at different times independently.

C When you want to block the main thread until a task finishes.

D When you want to write synchronous code without any asynchronous behavior.

💡 Hint

Think about how events allow multiple listeners and callbacks handle one response.

Events are useful when multiple things can happen over time and you want to react to each occurrence separately. Callbacks are simpler for one-time responses.

❓ component_behavior

intermediate

Output of event emitter with multiple listeners

What will be printed when this Node.js code runs?

Node.js

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('ping', () => console.log('First listener'));
emitter.on('ping', () => console.log('Second listener'));
emitter.emit('ping');

A No output

B First listener

C Second listener

D First listener\nSecond listener

💡 Hint

Remember that multiple listeners can respond to the same event.

Both listeners are registered for the 'ping' event, so emitting 'ping' calls both callbacks in order.

📝 Syntax

advanced

Identify the error in callback usage

What error does this code produce?

Node.js

function fetchData(callback) {
  setTimeout(() => {
    callback(null, 'data');
  }, 100);
}

fetchData((error, result) => {
  if (error) {
    console.log('Error:', error);
  } else {
    console.log('Result:', result);
  }
});

fetchData('not a function');

A TypeError: callback is not a function

B SyntaxError: Unexpected token

C No error, prints 'Result: data' twice

D ReferenceError: callback is not defined

💡 Hint

Check what happens when a non-function is passed as callback.

The second call passes a string instead of a function, so when setTimeout tries to call it, a TypeError occurs.

❓ state_output

advanced

State after event and callback usage

What is the value of the variable count after this code runs?

Node.js

const EventEmitter = require('events');
const emitter = new EventEmitter();
let count = 0;

emitter.on('increment', () => { count += 1; });

function doWork(callback) {
  emitter.emit('increment');
  callback();
}

doWork(() => { count += 10; });

A 11

B 10

C 0

D 1

💡 Hint

Consider the order of event emission and callback execution.

The event listener increments count by 1, then the callback adds 10, total 11.

🔧 Debug

expert

Why does the listener not run on the second emit?

Given this code, why does the second `emitter.emit('data')` not print anything?

Node.js

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.once('data', () => console.log('Data received'));

emitter.emit('data');
emitter.emit('data');

A The listener is removed before any emit happens.

B The listener is never registered because of a syntax error.

C The listener runs only once, so the second emit does nothing.

D The event name is misspelled in the emit calls.

💡 Hint

Check how the 'once' method works for event listeners.

The 'once' method registers a listener that runs only the first time the event is emitted. The second emit triggers no listener.

Practice

1. Which statement best describes when to use callbacks versus events in Node.js?

easy

A. Use callbacks for simple single responses and events for multiple listeners.

B. Use events only for synchronous code and callbacks for asynchronous code.

C. Callbacks are for error handling only, events are for all other tasks.

D. Events replace callbacks completely in modern Node.js.

Solution

1. Step 1: Understand callbacks and events roles

   Callbacks run one function after a task finishes, suitable for simple, single responses.

2. Step 2: Understand events usage

   Events allow many listeners to respond to named signals, useful for complex or multiple reactions.

3. Final Answer:

   Use callbacks for simple single responses and events for multiple listeners. -> Option A

4. Quick Check:

   Callbacks = single response, Events = multiple listeners [OK]

Hint: Callbacks = one response; events = many listeners [OK]

Common Mistakes:

• Thinking events are only for synchronous code
• Believing callbacks handle all errors exclusively
• Assuming events completely replace callbacks

2. Which of the following is the correct syntax to add an event listener in Node.js?

easy

A. emitter.listen('eventName', callbackFunction);

B. emitter.addListener('eventName' callbackFunction);

C. emitter.callback('eventName', callbackFunction);

D. emitter.on('eventName', callbackFunction);

Solution

1. Step 1: Recall Node.js event listener syntax

   The standard method to add an event listener is using emitter.on with event name and callback.

2. Step 2: Check each option for syntax correctness

   emitter.on('eventName', callbackFunction); uses correct syntax with parentheses and comma. emitter.addListener('eventName' callbackFunction); misses a comma. Options A and D use invalid method names.

3. Final Answer:

   emitter.on('eventName', callbackFunction); -> Option D

4. Quick Check:

   Correct event listener syntax = emitter.on(...) [OK]

Hint: Use emitter.on('event', callback) for events [OK]

Common Mistakes:

• Missing comma between arguments
• Using incorrect method names like listen or callback
• Confusing addListener syntax without comma

3. What will be the output of this Node.js code snippet?

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('greet', () => console.log('Hello!'));
emitter.emit('greet');
emitter.emit('greet');

medium

A. Hello! printed once

B. No output

C. Hello! printed twice

D. Error thrown

Solution

1. Step 1: Understand event listener and emit behavior

   Each call to emitter.emit triggers all listeners for that event. Here, 'greet' event has one listener printing 'Hello!'.

2. Step 2: Count how many times emit is called

   emit('greet') is called twice, so the listener runs twice, printing 'Hello!' two times.

3. Final Answer:

   Hello! printed twice -> Option C

4. Quick Check:

   emit triggers listeners each time = output twice [OK]

Hint: emit calls listeners every time it's invoked [OK]

Common Mistakes:

• Thinking emit triggers listener only once
• Expecting no output without callback arguments
• Confusing event registration with callback invocation

4. Identify the error in this Node.js code using callbacks and events:

const EventEmitter = require('events');
const emitter = new EventEmitter();
function task(callback) {
  emitter.emit('done');
  callback();
}
task(() => console.log('Callback finished'));
emitter.on('done', () => console.log('Event done'));

medium

A. The event listener is added after task is called, so event may be missed.

B. Callback should be called before emitting the event.

C. setTimeout is used incorrectly without delay argument.

D. EventEmitter cannot be used with callbacks.

Solution

1. Step 1: Check order of event listener and task call

   The event listener is added after task() is called, so the 'done' event may emit before listener exists.

2. Step 2: Understand event emission timing

   task emits 'done' synchronously when called, but listener is added after task() call, so emit happens before listener setup.

3. Final Answer:

   The event listener is added after task is called, so event may be missed. -> Option A

4. Quick Check:

   Listener must be added before event emit [OK]

Hint: Add event listeners before emitting events [OK]

Common Mistakes:

• Adding listeners after emitting events
• Confusing callback order with event order
• Assuming setTimeout needs no delay argument

5. You want to notify multiple parts of your Node.js app when a file download finishes, but also run a cleanup callback once. Which approach fits best?

hard

A. Use only events for everything including cleanup.

B. Use an event emitter to notify multiple listeners and a callback for cleanup after download.

C. Use multiple callbacks for each notification and cleanup.

D. Use only a callback for all notifications and cleanup.

Solution

1. Step 1: Analyze notification needs

   Multiple parts need to be notified, which fits event emitters allowing many listeners.

2. Step 2: Analyze cleanup requirement

   Cleanup runs once after download, suitable for a single callback after task completion.

3. Step 3: Combine approaches

   Use events for multiple notifications and a callback for single cleanup to keep code clear and efficient.

4. Final Answer:

   Use an event emitter to notify multiple listeners and a callback for cleanup after download. -> Option B

5. Quick Check:

   Events = multiple notifications, callback = single cleanup [OK]

Hint: Events for many, callback for one-time cleanup [OK]

Common Mistakes:

• Trying to use only callbacks for multiple notifications
• Using multiple callbacks instead of events
• Using events for single cleanup unnecessarily