Error events and handling in Node.js - Step-by-Step Execution

Concept Flow - Error events and handling

Start program

↓

Run code that may error

↓

Error occurs?

No→Continue normal flow

Yes↓

Emit 'error' event

↓

Is 'error' event handled?

No→Program crashes

Yes↓

Run error handler callback

↓

Recover or log error

↓

Continue or exit gracefully

This flow shows how Node.js runs code, emits error events when problems happen, and either handles them or crashes.

Execution Sample

Node.js

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

This code creates an event emitter, listens for 'error' events, and emits one to show handling.

Execution Table

Step	Action	Event Emitted?	Handler Called?	Output
1	Create EventEmitter instance	No	No
2	Attach 'error' event listener	No	No
3	Emit 'error' event with Error('Oops')	Yes	Yes	Error handled: Oops
4	Program continues normally	No	No

💡 Program stops if 'error' event emitted without handler; here handler exists so program continues.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
emitter	undefined	EventEmitter instance	Same instance with listener	Same instance after emit	Same instance

Key Moments - 2 Insights

What happens if we emit an 'error' event but do not add an 'error' listener?

Node.js will crash the program because the 'error' event is special and must be handled. See execution_table step 3 where handler is called; without it, program stops.

Why do we need to attach the 'error' event listener before emitting the event?

If the listener is not attached before emitting, the event will have no handler and cause a crash. The execution_table shows listener attached at step 2 before emitting at step 3.

Visual Quiz - 3 Questions

Look at the execution table, what is printed when the 'error' event is emitted at step 3?

A Error handled: Oops

B Program crashes

C No output

D Unhandled exception

💡 Hint

Check the Output column at step 3 in the execution_table.

At which step is the 'error' event listener attached?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the Action column in execution_table for when listener is added.

If we remove the listener attachment at step 2, what will happen at step 3?

A Error handled: Oops

B No output but program continues

C Program crashes

D Event ignored silently

💡 Hint

Refer to key_moments about missing 'error' listener causing crash.

Concept Snapshot

Node.js emits 'error' events on problems.
You must add an 'error' listener to handle them.
If no listener, program crashes.
Attach listener before emitting errors.
Use emitter.on('error', callback) to catch errors.
Emit errors with emitter.emit('error', errorObject).

Full Transcript

In Node.js, when something goes wrong, an 'error' event is emitted. This event is special: if no code listens for it, the program crashes immediately. To avoid this, you add an 'error' event listener using emitter.on('error', callback). When the error event is emitted, the callback runs, letting you handle or log the error. The flow starts with creating an EventEmitter, attaching the listener, then emitting the error event. If the listener is missing, the program stops. This example shows how to safely catch errors and keep your program running.

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