Event-driven architecture in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this Express event listener do?

Consider this Express app snippet that listens for a custom event. What will be logged when the event 'userRegistered' is emitted?

Express

const express = require('express');
const EventEmitter = require('events');
const app = express();
const eventEmitter = new EventEmitter();

eventEmitter.on('userRegistered', (user) => {
  console.log(`Welcome ${user.name}!`);
});

// Emitting event
const newUser = { name: 'Alice' };
eventEmitter.emit('userRegistered', newUser);

A Welcome Alice!

B userRegistered event emitted

C Error: eventEmitter.emit is not a function

D No output

💡 Hint

Think about what happens when the 'userRegistered' event is emitted and how the listener reacts.

The event listener listens for 'userRegistered' and logs a welcome message with the user's name when the event is emitted.

📝 Syntax

intermediate

Identify the syntax error in this Express event code

Which option contains the correct syntax to listen for an event named 'dataReceived' using Node.js EventEmitter in Express?

Express

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

// Choose the correct listener syntax

A emitter.listen('dataReceived', (data) => console.log(data));

B emitter.on('dataReceived' (data) => console.log(data));

C emitter.addListener('dataReceived', (data) => console.log(data));

D emitter.on('dataReceived', (data) => console.log(data));

💡 Hint

Check the method names and syntax for event listeners in Node.js EventEmitter.

The correct method to listen for events is 'on'. Option D uses a non-existent method 'listen'. Option D is valid Node.js syntax but not the best choice here since only one correct answer is allowed. Option D misses a comma causing syntax error.

❓ state_output

advanced

What is the output after emitting multiple events?

Given this Express event-driven code, what will be the console output after running it?

Express

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

let count = 0;
emitter.on('increment', () => {
  count += 1;
  console.log(`Count is now ${count}`);
});

emitter.emit('increment');
emitter.emit('increment');
emitter.emit('increment');

A No output

B

Count is now 1
Count is now 2
Count is now 3

C

Count is now 1
Count is now 1
Count is now 1

D Count is now 3

💡 Hint

Each 'increment' event triggers the listener that increases count and logs it.

Each time 'increment' is emitted, the listener runs, increasing count by 1 and logging the new value. So three emits produce three logs with increasing count.

🔧 Debug

advanced

Why does this Express event listener not respond?

This code intends to log a message when 'orderPlaced' event is emitted, but nothing happens. What is the cause?

Express

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

emitter.once('orderPlaced', () => {
  console.log('Order received!');
});

// Later in code
emitter.emit('orderPlaced');
emitter.emit('orderPlaced');

A EventEmitter is not imported correctly.

B The event name is misspelled in the emit call.

C The listener only runs once, so only the first emit triggers the log.

D The listener should use 'on' instead of 'once' to work.

💡 Hint

Check how 'once' differs from 'on' in event listeners.

'once' listens for the event only one time. The first emit triggers the listener and logs the message. The second emit does nothing because the listener was removed after first call.

🧠 Conceptual

expert

Which statement best describes event-driven architecture in Express?

Select the option that correctly explains the main advantage of using event-driven architecture in an Express app.

A It allows the app to respond asynchronously to events, improving scalability and responsiveness.

B It forces all code to run synchronously, ensuring predictable execution order.

C It eliminates the need for middleware by handling all logic in event listeners.

D It requires the app to restart after every event to update state.

💡 Hint

Think about how events help apps handle multiple tasks without waiting.

Event-driven architecture lets the app react to events as they happen, often asynchronously, which helps handle many tasks efficiently without blocking.