Error events and handling in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to listen for an error event on a Node.js EventEmitter.

Node.js

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('error', [1] => {
  console.error('Error occurred:', [1].message);
});

Drag options to blanks, or click blank then click option'

Aevent

Berror

Cerr

De

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'event' or 'error' as the parameter name without matching usage inside the function.

Not providing a parameter to the callback function.

The error event handler receives the error object as the first argument. Using err is a common convention.

2fill in blank

medium

Complete the code to emit an error event with a custom error message.

Node.js

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.emit('error', new [1]('Something went wrong'));

Drag options to blanks, or click blank then click option'

AException

BMessage

CEvent

DError

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-existent class like 'Exception' or 'Message'.

Passing a string directly instead of an Error object.

In Node.js, errors are usually instances of the built-in Error class.

3fill in blank

hard

Fix the error in the code to properly handle errors emitted by the EventEmitter.

Node.js

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

emitter.on('error', function([1]) {
  console.log('An error happened:', [1].message);
});

Drag options to blanks, or click blank then click option'

Aerr

Berror

Cthis

Devent

Attempts:

3 left

💡 Hint

Common Mistakes

Not defining a parameter in the callback function.

Using 'this' to access the error object.

The error handler function must accept the error object as a parameter to access its properties.

4fill in blank

hard

Fill both blanks to create an error handler that logs the error stack and exits the process.

Node.js

emitter.on('error', ([1]) => {
  console.error([2].stack);
  process.exit(1);
});

Drag options to blanks, or click blank then click option'

Aerr

Berror

Ce

Devent

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the parameter and inside the function.

Trying to access stack on a variable that is not the error object.

The error object is passed as a parameter, commonly named err, and its stack property shows the error trace.

5fill in blank

hard

Fill all three blanks to create a try-catch block that emits an error event on failure.

Node.js

try {
  JSON.parse([1]);
} catch ([2]) {
  emitter.emit([3], [2]);
}

Drag options to blanks, or click blank then click option'

A'{"name":"John"}'

Berr

C'error'

D'data'

Attempts:

3 left

💡 Hint

Common Mistakes

Using invalid JSON string in the first blank.

Using wrong parameter name in catch block.

Emitting a wrong event name instead of 'error'.

The JSON.parse method parses a JSON string. The catch block catches the error as err and emits an 'error' event with it.

Practice

1. What is the main purpose of handling error events in Node.js event emitters?

easy

A. To improve the speed of the application

B. To automatically restart the server

C. To catch and respond to problems in asynchronous code

D. To log user activity

Solution

1. Step 1: Understand the role of error events

   Error events in Node.js are emitted when something goes wrong in asynchronous operations.

2. Step 2: Identify the purpose of handling errors

   Handling these events allows the program to respond properly, avoiding crashes and improving stability.

3. Final Answer:

   To catch and respond to problems in asynchronous code -> Option C

4. Quick Check:

   Error events catch async problems = B [OK]

Hint: Error events catch async problems to keep app stable [OK]

Common Mistakes:

• Thinking error events improve speed
• Assuming error events restart servers automatically
• Confusing error events with logging user actions

2. Which of the following is the correct way to listen for an error event on a Node.js stream named myStream?

easy

A. myStream.catch('error', (err) => { console.error(err); });

B. myStream.error((err) => { console.error(err); });

C. myStream.listen('error', (err) => { console.error(err); });

D. myStream.on('error', (err) => { console.error(err); });

Solution

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

   Node.js uses the on method to listen to events on event emitters like streams.

2. Step 2: Verify the correct method and parameters

   The correct syntax is myStream.on('error', callback) where callback receives the error object.

3. Final Answer:

   myStream.on('error', (err) => { console.error(err); }); -> Option D

4. Quick Check:

   Use .on('error', callback) to handle errors [OK]

Hint: Use .on('error', callback) to handle errors [OK]

Common Mistakes:

• Using .error() instead of .on()
• Using .listen() or .catch() which don't exist
• Missing the event name string 'error'

3. Consider this code snippet:

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('error', (err) => { console.log('Error caught:', err.message); });
emitter.emit('error', new Error('Oops!'));

What will be printed to the console?

medium

A. Error caught: Oops!

B. Unhandled 'error' event

C. Error: Oops!

D. No output

Solution

1. Step 1: Analyze the event listener setup

   The code sets a listener for the 'error' event that logs the error message prefixed by 'Error caught:'.

2. Step 2: Understand the emitted event

   The emitter emits an 'error' event with an Error object having message 'Oops!'. The listener runs and logs the message.

3. Final Answer:

   Error caught: Oops! -> Option A

4. Quick Check:

   Handled error event logs message = A [OK]

Hint: If error event has listener, it logs message [OK]

Common Mistakes:

• Expecting unhandled error crash
• Confusing error object with string output
• Thinking no output occurs without console.log

4. What is wrong with this code snippet?

const fs = require('fs');
const stream = fs.createReadStream('file.txt');
stream.emit('error', new Error('File not found'));

medium

A. Manually emitting 'error' event is incorrect; errors should come from the system

B. The error event listener is missing, so it will crash

C. The file path should be absolute

D. createReadStream does not emit error events

Solution

1. Step 1: Understand error event emission

   Error events on streams are emitted by the system when errors occur, not manually by user code.

2. Step 2: Identify the misuse of emit

   Calling emit('error') manually on a stream is not standard practice and can cause unexpected behavior.

3. Final Answer:

   Manually emitting 'error' event is incorrect; errors should come from the system -> Option A

4. Quick Check:

   Don't manually emit 'error' on streams [OK]

Hint: Let system emit errors; don't call emit('error') yourself [OK]

Common Mistakes:

• Thinking manual emit is normal
• Assuming missing listener causes error here
• Believing file path must be absolute always

5. You want to create a simple HTTP server in Node.js that handles errors gracefully. Which code snippet correctly handles errors on the server to avoid crashes?

hard

A. const http = require('http');
const server = http.createServer((req, res) => { res.end('Hello'); });
server.emit('error', new Error('Oops'));
server.listen(3000);

B. const http = require('http');
const server = http.createServer((req, res) => { res.end('Hello'); });
server.on('error', (err) => { console.error('Server error:', err); });
server.listen(3000);

C. const http = require('http');
const server = http.createServer((req, res) => { throw new Error('Oops'); });
server.listen(3000);

D. const http = require('http');
const server = http.createServer((req, res) => { res.end('Hello'); });
server.on('request', (req, res) => { throw new Error('Oops'); });
server.listen(3000);

Solution

1. Step 1: Identify proper error handling on server

   Listening to the 'error' event on the server allows catching errors and logging them without crashing.

2. Step 2: Check other options for issues

   const http = require('http'); const server = http.createServer((req, res) => { throw new Error('Oops'); }); server.listen(3000); throws error inside request handler without catching, causing crash. const http = require('http'); const server = http.createServer((req, res) => { res.end('Hello'); }); server.emit('error', new Error('Oops')); server.listen(3000); manually emits error, which is wrong. const http = require('http'); const server = http.createServer((req, res) => { res.end('Hello'); }); server.on('request', (req, res) => { throw new Error('Oops'); }); server.listen(3000); throws error inside 'request' event without handling.

3. Final Answer:

   Code that listens to 'error' event and logs errors -> Option B

4. Quick Check:

   Listen to 'error' event on server to handle errors [OK]

Hint: Always listen to 'error' event on servers to avoid crashes [OK]

Common Mistakes:

• Throwing errors without try/catch or error event listener
• Manually emitting error events on server
• Ignoring error events causing app crash