JavaScript has 8 built-in error types (TypeError, RangeError, SyntaxError, etc.) plus the base Error class. Unlike Python, JavaScript doesn't have a strong exception hierarchy convention — but building one with custom error classes dramatically improves debuggability. Proper error handling is what separates hobby projects from production systems.
1. TypeError: Cannot read properties of null (reading 'property')
2. ReferenceError: undefinedVar is not defined
3. RangeError: Invalid array length
4. URIError: URI malformed
class AppError extends Error {
constructor(message, code, details = {}) {
super(message);
this.name = this.constructor.name;
this.code = code;
this.details = details;
Error.captureStackTrace?.(this, this.constructor);
}
}
class ValidationError extends AppError {
constructor(field, message, value) {
super(message, "VALIDATION_ERROR", { field, value });
this.field = field;
}
}
class NotFoundError extends AppError {
constructor(resource, id) {
super(`${resource} not found: ${id}`, "NOT_FOUND", { resource, id });
}
}
class AuthError extends AppError {
constructor(reason = "Unauthorized") {
super(reason, "AUTH_ERROR");
}
}
// Test hierarchy
function validateUser(user) {
if (!user.name) throw new ValidationError("name", "Name is required", user.name);
if (user.age < 0 || user.age > 150) throw new ValidationError("age", "Invalid age", user.age);
return true;
}
const testUsers = [
{ name: "Alice", age: 30 },
{ name: "", age: 25 },
{ name: "Bob", age: -5 },
];
for (const user of testUsers) {
try {
validateUser(user);
console.log(`✅ Valid user: ${user.name || "(empty)"}`);
} catch (e) {
if (e instanceof ValidationError) {
console.log(`❌ ValidationError [${e.field}]: ${e.message}`);
} else if (e instanceof AppError) {
console.log(`❌ AppError [${e.code}]: ${e.message}`);
}
}
}
✅ Valid user: Alice
❌ ValidationError [name]: Name is required
❌ ValidationError [age]: Invalid age
function riskyOperation(value) {
try {
console.log(` [try] Processing ${value}`);
if (typeof value !== "number") throw new TypeError(`Expected number, got ${typeof value}`);
if (value < 0) throw new RangeError(`Value must be non-negative: ${value}`);
const result = Math.sqrt(value);
console.log(` [try] Result: ${result.toFixed(4)}`);
return result;
} catch (err) {
console.log(` [catch] ${err.constructor.name}: ${err.message}`);
return NaN;
} finally {
// ALWAYS executes — even if catch re-throws
console.log(` [finally] Cleanup for value=${value}`);
}
}
[16, -4, "abc", 25].forEach(v => {
console.log(`\nprocessing: ${JSON.stringify(v)}`);
riskyOperation(v);
});
processing: 16
[try] Processing 16
[try] Result: 4.0000
[finally] Cleanup for value=16
processing: -4
[try] Processing -4
[catch] RangeError: Value must be non-negative: -4
[finally] Cleanup for value=-4
processing: "abc"
[try] Processing abc
[catch] TypeError: Expected number, got string
[finally] Cleanup for value=abc
processing: 25
[try] Processing 25
[try] Result: 5.0000
[finally] Cleanup for value=25
class DatabaseError extends Error {
constructor(query, cause) {
super(`Query failed: ${query}`);
this.name = "DatabaseError";
this.cause = cause; // ES2022 error cause
}
}
function lowLevelDB(query) {
if (query.includes("DROP")) throw new Error("Forbidden: DROP operations");
return [{ id: 1, name: "Alice" }];
}
function userRepository(userId) {
try {
const query = `SELECT * FROM users WHERE id = ${userId}`;
return lowLevelDB(query)[0];
} catch (cause) {
throw new DatabaseError(`SELECT user ${userId}`, cause);
}
}
function userService(userId) {
try {
const user = userRepository(userId);
return { success: true, user };
} catch (e) {
if (e instanceof DatabaseError) {
console.log(`Service caught DB error: ${e.message}`);
return { success: false, error: e.message };
}
throw e; // Re-throw unknown errors
}
}
console.log(userService(1));
console.log(userService(2));
