Academy — Sanjib Sikder

What Happens When Code Throws

Before learning to handle errors, see exactly what an unhandled error looks like:

JavaScript

Ctrl+Enter to run

function divide(a, b) {
  if (b === 0) throw new Error("Cannot divide by zero");
  return a / b;
}

console.log(divide(10, 2)); // works fine
console.log(divide(10, 0)); // throws — execution stops here
console.log("This line never runs");

When an error is thrown and nothing catches it, execution stops immediately. Every line after the throw is skipped. In a real application this means a crashed page, a failed request, a lost transaction. Error handling is how you take back control.

try / catch — The Basic Pattern

JavaScript

Ctrl+Enter to run

function divide(a, b) {
  if (b === 0) throw new Error("Cannot divide by zero");
  return a / b;
}

try {
console.log(divide(10, 2)); // succeeds
console.log(divide(10, 0)); // throws
console.log("Never reached"); // skipped
} catch (err) {
console.log("Caught:", err.message);
}

console.log("Program continues normally");

The try block is the code you want to run. The catch block runs only if something inside try throws. After either path, execution continues normally. The error does not propagate, the program does not crash.

err is a real object — it has .message, .name, and .stack. You are not just catching a string.

finally — Code That Always Runs

finally runs whether the try succeeded, threw, or the catch itself threw. It is guaranteed:

JavaScript

Ctrl+Enter to run

function processData(input) {
  console.log("Opening resource…");

try {
if (typeof input !== "number") throw new TypeError("Expected a number");
if (input < 0) throw new RangeError("Number must be non-negative");

    const result = Math.sqrt(input);
    console.log("Result:", result.toFixed(4));
    return result;

} catch (err) {
console.log(`Error (${err.name}): ${err.message}`);
} finally {
// This ALWAYS runs — success, failure, doesn't matter
console.log("Resource closed.");
}
}

processData(25);
console.log("---");
processData(-4);
console.log("---");
processData("hello");

finally is for cleanup that must happen regardless of outcome — closing a file, releasing a lock, hiding a loading spinner. It is not optional cleanup — it is guaranteed cleanup.

The Error Object in Detail

JavaScript has several built-in error types, each with a specific meaning:

JavaScript

Ctrl+Enter to run

const errors = [
  new Error("Generic error"),
  new TypeError("Wrong type"),
  new RangeError("Value out of range"),
  new ReferenceError("Variable not defined"),
  new SyntaxError("Bad syntax"),
];

for (const err of errors) {
console.log(`[${err.name}] ${err.message}`);
}

// You can check the type in catch
function test(value) {
try {
if (typeof value !== "string") throw new TypeError("Need a string");
if (value.length === 0) throw new RangeError("String is empty");
return value.toUpperCase();
} catch (err) {
if (err instanceof TypeError) console.log("Type problem:", err.message);
if (err instanceof RangeError) console.log("Range problem:", err.message);
}
}

test(42);
test("");
test("hello");

instanceof lets you catch different error types and respond differently — the same way you would handle a network timeout differently from a permission error.

Custom Error Classes

Built-in error types are too generic for real applications. Define your own so errors carry meaning specific to your domain:

JavaScript

Ctrl+Enter to run

class ValidationError extends Error {
  constructor(field, message) {
    super(message);
    this.name  = "ValidationError";
    this.field = field;
  }
}

class NotFoundError extends Error {
constructor(resource, id) {
super(`${resource} with id ${id} not found`);
this.name = "NotFoundError";
this.resource = resource;
this.id = id;
}
}

function findStudent(id, db) {
const student = db.find(s => s.id === id);
if (!student) throw new NotFoundError("Student", id);
return student;
}

function validateMarks(marks) {
if (typeof marks !== "number") throw new ValidationError("marks", "Must be a number");
if (marks < 0 || marks > 100) throw new ValidationError("marks", "Must be between 0 and 100");
}

const db = [{ id: 1, name: "Rahul" }, { id: 2, name: "Priya" }];

try {
const s = findStudent(99, db);
} catch (err) {
if (err instanceof NotFoundError) {
console.log(`Not found: ${err.resource} #${err.id}`);
}
}

try {
validateMarks(150);
} catch (err) {
if (err instanceof ValidationError) {
console.log(`Validation failed on '${err.field}': ${err.message}`);
}
}

class ValidationError extends Error {
  constructor(field, message) {
    super(message);
    this.name  = "ValidationError";
    this.field = field;
  }
}

class NotFoundError extends Error {
constructor(resource, id) {
super(`${resource} with id ${id} not found`);
this.name = "NotFoundError";
this.resource = resource;
this.id = id;
}
}

function findStudent(id, db) {
const student = db.find(s => s.id === id);
if (!student) throw new NotFoundError("Student", id);
return student;
}

function validateMarks(marks) {
if (typeof marks !== "number") throw new ValidationError("marks", "Must be a number");
if (marks < 0 || marks > 100) throw new ValidationError("marks", "Must be between 0 and 100");
}

const db = [{ id: 1, name: "Rahul" }, { id: 2, name: "Priya" }];

try {
const s = findStudent(99, db);
} catch (err) {
if (err instanceof NotFoundError) {
console.log(`Not found: ${err.resource} #${err.id}`);
}
}

try {
validateMarks(150);
} catch (err) {
if (err instanceof ValidationError) {
console.log(`Validation failed on '${err.field}': ${err.message}`);
}
}

Custom errors carry extra fields (field, resource, id) so catching code has all the context it needs to respond intelligently — log it, show a user message, retry, or escalate.

Re-throwing — Catching Only What You Can Handle

A common mistake: a catch block swallows errors it doesn't understand. Always re-throw what you cannot handle:

JavaScript

Ctrl+Enter to run

class AppError extends Error {
  constructor(msg) { super(msg); this.name = "AppError"; }
}

function riskyOperation(n) {
if (n === 0) throw new AppError("App-level failure");
if (n < 0) throw new RangeError("Unexpected negative");
return n * 10;
}

function handleOperation(n) {
try {
return riskyOperation(n);
} catch (err) {
if (err instanceof AppError) {
// We know how to handle this one
console.log("Handled AppError:", err.message);
return null;
}
// We don't handle RangeError here — let it propagate
throw err;
}
}

// AppError — handled
console.log(handleOperation(0));

// RangeError — caught by outer handler
try {
handleOperation(-1);
} catch (err) {
console.log("Outer caught:", err.name, err.message);
}

// Normal case
console.log(handleOperation(5));

Catch blocks that silently swallow every error are one of the hardest bugs to track down. If you do not know what to do with an error, re-throw it and let something higher up decide.

Error Handling in Async Code

Errors in promises and async/await follow the same logic — they just travel through promise chains instead of call stacks:

JavaScript

Ctrl+Enter to run

function fetchScore(id) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (id <= 0)  return reject(new RangeError("ID must be positive"));
      if (id > 100) return reject(new NotFoundError("Student", id));
      resolve({ id, score: 50 + id });
    }, 30);
  });
}

class NotFoundError extends Error {
constructor(resource, id) {
super(`${resource} ${id} not found`);
this.name = "NotFoundError";
}
}

async function loadStudent(id) {
try {
const student = await fetchScore(id);
console.log(`Student ${student.id}: ${student.score} marks`);
} catch (err) {
if (err instanceof RangeError) console.log("Bad input:", err.message);
else if (err instanceof NotFoundError) console.log("Missing:", err.message);
else throw err; // unexpected — re-throw
}
}

loadStudent(42);
loadStudent(-1);
loadStudent(999);

try/catch wraps await exactly as it wraps synchronous code. The error that was rejected in the promise surfaces as a thrown error inside the async function. Same mental model, same tools.

A Robust Function — Putting It All Together

JavaScript

Ctrl+Enter to run

class ValidationError extends Error {
  constructor(field, msg) {
    super(msg); this.name = "ValidationError"; this.field = field;
  }
}

function parseStudentRecord(raw) {
if (typeof raw !== "object" || raw === null) {
throw new TypeError("Record must be an object");
}
if (!raw.name || typeof raw.name !== "string") {
throw new ValidationError("name", "Name is required and must be a string");
}
if (typeof raw.marks !== "number" || raw.marks < 0 || raw.marks > 100) {
throw new ValidationError("marks", "Marks must be a number between 0 and 100");
}

return {
name: raw.name.trim(),
marks: raw.marks,
grade: raw.marks >= 75 ? "A" : raw.marks >= 50 ? "B" : "C",
};
}

const inputs = [
{ name: "Rahul", marks: 82 }, // valid
{ name: "Priya", marks: 150 }, // marks out of range
{ name: "", marks: 75 }, // empty name
null, // not an object
{ name: "Arjun", marks: 49 }, // valid
];

for (const input of inputs) {
try {
const record = parseStudentRecord(input);
console.log(`✓ ${record.name}: ${record.marks} [${record.grade}]`);
} catch (err) {
if (err instanceof ValidationError) {
console.log(`✗ Validation [${err.field}]: ${err.message}`);
} else if (err instanceof TypeError) {
console.log(`✗ Type error: ${err.message}`);
} else {
throw err;
}
}
}

class ValidationError extends Error {
  constructor(field, msg) {
    super(msg); this.name = "ValidationError"; this.field = field;
  }
}

return {
name: raw.name.trim(),
marks: raw.marks,
grade: raw.marks >= 75 ? "A" : raw.marks >= 50 ? "B" : "C",
};
}

const inputs = [
{ name: "Rahul", marks: 82 }, // valid
{ name: "Priya", marks: 150 }, // marks out of range
{ name: "", marks: 75 }, // empty name
null, // not an object
{ name: "Arjun", marks: 49 }, // valid
];

for (const input of inputs) {
try {
const record = parseStudentRecord(input);
console.log(`✓ ${record.name}: ${record.marks} [${record.grade}]`);
} catch (err) {
if (err instanceof ValidationError) {
console.log(`✗ Validation [${err.field}]: ${err.message}`);
} else if (err instanceof TypeError) {
console.log(`✗ Type error: ${err.message}`);
} else {
throw err;
}
}
}

This is what error handling looks like in production code — validate inputs explicitly, throw typed errors with meaningful messages, catch them where you can respond appropriately, re-throw what you cannot.

What You Have Learned

Errors are not exceptions to normal programming — they are a normal part of it. The question is always whether you handle them intentionally or let them handle you.

The key ideas:

An unhandled throw stops execution immediately — everything after it is skipped
try/catch catches thrown errors and keeps the program running
finally runs regardless of outcome — guaranteed cleanup
Built-in error types (TypeError, RangeError, etc.) carry specific meaning — use instanceof to distinguish them
Custom error classes extend Error and carry domain-specific context — prefer these in any real application
Re-throw errors you cannot handle — never silently swallow what you don't understand
try/catch wraps await exactly as it wraps synchronous code — same tool, same mental model

In the next lesson: Modules — how to split JavaScript across multiple files, export what others need, import what you need, and build a codebase that scales without collapsing into a single enormous file.