Node.js Error Handling

Why Handle Errors?

It prevents applications from crashing unexpectedly

It provides meaningful feedback to users

It helps maintain application stability in production

It ensures resources are properly cleaned up

JSON.parse('{invalid json}');
// TypeError null.someProperty;
// ReferenceError unknownVariable;

// ENOENT: No such file or directory const fs = require('fs');

fs.readFile('nonexistent.txt', (err) => {
console.error(err.code); // 'ENOENT'
});

// ECONNREFUSED: Connection refused const http = require('http');

const req = http.get('http://nonexistent-site.com', (res) => {});
req.on('error', (err) => {
console.error(err.code); // 'ECONNREFUSED' or 'ENOTFOUND'
});

Basic Error Handling

Error-First Callbacks

function readConfigFile(filename, callback) {
fs.readFile(filename, 'utf8', (err, data) => {
if (err) {
// Handle specific error types if (err.code === 'ENOENT') {
return callback(new Error(`Config file ${filename} not found`));
} else if (err.code === 'EACCES') {
return callback(new Error(`No permission to read ${filename}`));
}
// For all other errors return callback(err);
}
// Process data if no error try {
const config = JSON.parse(data);
callback(null, config);
} catch (parseError) {
callback(new Error(`Invalid JSON in ${filename}`));
}
});
}
// Usage readConfigFile('config.json', (err, config) => {
if (err) {
console.error('Failed to read config:', err.message);
// Handle the error (e.g., use default config)
return;
}
console.log('Config loaded successfully:', config);
});

Modern Error Handling

Using try...catch with Async/Await
With async/await, you can use try/catch blocks for both synchronous and asynchronous code:

async function loadUserData(userId) {
try {
const data = await fs.readFile(`users/${userId}.json`, 'utf8');
const user = JSON.parse(data);
if (!user.email) {
throw new Error('Invalid user data: missing email');
}
return user;
} catch (error) {
// Handle different error types if (error.code === 'ENOENT') {
throw new Error(`User ${userId} not found`);
} else if (error instanceof SyntaxError) {
throw new Error('Invalid user data format');
}
// Re-throw other errors throw error;
} finally {
// Cleanup code that runs whether successful or not console.log(`Finished processing user ${userId}`);
}
}

(async () => {
try {
const user = await loadUserData(123);
console.log('User loaded:', user);
} catch (error) {
console.error('Failed to load user:', error.message);
// Handle error (e.g., show to user, retry, etc.)
}
})();

Global Error Handling

Uncaught Exceptions

Example: Global Error Handlers

process.on('uncaughtException', (error) => {
console.error('UNCAUGHT EXCEPTION! Shutting down...');
console.error(error.name, error.message);
// Perform cleanup (close database connections, etc.)
server.close(() => {
console.log('Process terminated due to uncaught exception');
process.exit(1); // Exit with failure
});
});
// Handle unhandled promise rejections process.on('unhandledRejection', (reason, promise) => {
console.error('UNHANDLED REJECTION! Shutting down...');
console.error('Unhandled Rejection at:', promise, 'Reason:', reason);
// Close server and exit server.close(() => {
process.exit(1);
});
});

Promise.reject(new Error('Something went wrong'));
// Example of an uncaught exception setTimeout(() => {
throw new Error('Uncaught exception after timeout');
}, 1000);

Error Handling Best Practices

Dos and Don'ts

Handle errors at the appropriate level

Log errors with sufficient context

Use custom error types for different scenarios

Clean up resources in finally blocks

Validate input to catch errors early

Don't

Expose sensitive error details to clients

Use try/catch for flow control

Swallow errors without logging them

Continue execution after unrecoverable errors

Custom Error Types class ValidationError extends Error {
constructor(message, field) {
super(message);
this.name = 'ValidationError';
this.field = field;
this.statusCode = 400;
}
}
class NotFoundError extends Error {
constructor(resource) {
super(`${resource} not found`);
this.name = 'NotFoundError';
this.statusCode = 404;
}
}
// Usage function getUser(id) {
if (!id) {
throw new ValidationError('User ID is required', 'id');
}

}

Summary