In JavaScript, an error is an object thrown to signal that an abnormal condition or runtime failure occurred. All built-in error types inherit from the foundational Error.prototype and expose three essential properties:

try {
  // Deliberately calling a method on null
  const profile = null;
  profile.getUsername(); 
} catch (err) {
  console.log("Error Name:   ", err.name);    // "TypeError"
  console.log("Error Message:", err.message); // "Cannot read properties of null (reading 'getUsername')"
  console.log("Stack Trace:  \n", err.stack);  // Full chronological call stack with line numbers
}

The ECMAScript specification defines six core standard Error constructors that inherit directly from Error. Recognizing these types allows you to write precise diagnostic and recovery handlers:

The try...catch...finally construct allows you to intercept runtime errors and prevent your entire application from abruptly crashing.

function processTransaction(account, amount) {
  let isLocked = true;
  console.log("1. Account locked for processing.");

  try {
    if (amount > account.balance) {
      throw new RangeError("Insufficient funds: balance is " + account.balance);
    }
    account.balance -= amount;
    console.log("2. Transaction successful. New balance:", account.balance);
    return true; // Notice: returning from inside try!
  } catch (err) {
    console.warn("2. Transaction rejected:", err.message);
    return false;
  } finally {
    // ALWAYS RUNS — perfect for closing database connections, unlocking mutexes, stopping loading spinners
    isLocked = false;
    console.log("3. FINALLY: Account unlocked safely. isLocked =", isLocked);
  }
}

const userAccount = { balance: 250 };
processTransaction(userAccount, 100); // Successfully deducts and unlocks
processTransaction(userAccount, 500); // Traps RangeError, handles error, and unlocks

The throw keyword interrupts standard execution and throws an exception. While JavaScript allows you to throw any value (strings, numbers, objects), always throw an instance of Error (or an extended subclass) so that call stack traces and prototype chains are preserved.

// Base Application Error
class AppError extends Error {
  constructor(message, statusCode = 500, errorCode = "INTERNAL_ERROR") {
    super(message);
    this.name = this.constructor.name;
    this.statusCode = statusCode;
    this.errorCode = errorCode;
    this.timestamp = new Date().toISOString();
    
    // Capture clean V8 stack trace excluding constructor frame
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, this.constructor);
    }
  }
}

// Specialized Validation Error
class ValidationError extends AppError {
  constructor(message, invalidFields = []) {
    super(message, 400, "VALIDATION_FAILED");
    this.invalidFields = invalidFields;
  }
}

// Specialized Authentication Error
class AuthError extends AppError {
  constructor(message = "Authentication required") {
    super(message, 401, "UNAUTHORIZED");
  }
}

// Usage in business logic
function registerUser(userData) {
  if (!userData.email || !userData.email.includes("@")) {
    throw new ValidationError("Invalid email provided", ["email"]);
  }
  if (!userData.token) {
    throw new AuthError("Session expired, please log in again");
  }
  return { success: true, user: userData };
}

try {
  registerUser({ email: "invalid-email" });
} catch (err) {
  if (err instanceof ValidationError) {
    console.error(`[${err.errorCode}] ${err.message} (Fields: ${err.invalidFields.join(", ")})`);
  } else if (err instanceof AuthError) {
    console.error(`[${err.errorCode}] Redirecting to login page...`);
  } else {
    console.error("Unknown system failure:", err);
  }
}

Catching errors is only half the battle. Good architecture requires knowing when to re-throw unexpected errors and how to monitor global unhandled rejections:

// 1. Re-throwing unknown errors
function loadUserData(jsonStr) {
  try {
    const data = JSON.parse(jsonStr);
    return data.user;
  } catch (err) {
    if (err instanceof SyntaxError) {
      console.warn("Recovering from corrupted cache JSON. Using empty default.");
      return null;
    }
    // Unknown bug: Re-throw to caller!
    throw err;
  }
}

// 2. Global Unhandled Rejection Monitor (Browser)
window.addEventListener("unhandledrejection", (event) => {
  console.error("TELEMETRY ALERT: Unhandled Promise Rejection:", event.reason);
  // Send to server logging API
  // fetch('/api/logs', { method: 'POST', body: JSON.stringify({ error: event.reason.message }) });
});