JavaScript try/catch Tutorial: Advanced Error Handling

try {
  // Code that might throw
  const data = JSON.parse(rawInput);
  processData(data);
} catch (error) {
  // Runs if try block throws
  console.error("Parse or process error:", error.message);
} finally {
  // ALWAYS runs — after try OR catch
  cleanup();
}

function example() {
  try {
    return "from try";     // finally still runs!
  } finally {
    console.log("finally runs"); // Logs before returning
    // NOT returning here — the "from try" value is preserved
  }
}
console.log(example()); // "finally runs", then "from try"
 
// If finally DOES return, it overrides the try/catch return:
function overrideExample() {
  try {
    return "from try";
  } finally {
    return "from finally"; // Overrides!
  }
}
console.log(overrideExample()); // "from finally"

// Using instanceof to check error type
try {
  const user = JSON.parse(input);
  await saveUser(user);
} catch (error) {
  if (error instanceof SyntaxError) {
    // Input was malformed JSON
    showValidationMessage("Invalid JSON format");
  } else if (error instanceof NetworkError) {
    // Save failed due to network
    queueForRetry(user);
  } else if (error instanceof AuthError) {
    // Missing permissions
    redirectToLogin();
  } else {
    // Unknown error — log and rethrow
    logError(error);
    throw error;
  }
}

// BAD: swallowing unknown errors
try {
  riskyOperation();
} catch (error) {
  console.log("Something went wrong");
  // Error is silently consumed — caller has no idea it failed
}
 
// GOOD: only handle what you understand, rethrow the rest
try {
  riskyOperation();
} catch (error) {
  if (error instanceof KnownError) {
    handleGracefully(error);
  } else {
    throw error; // Rethrow — let a higher layer handle it
  }
}

try {
  await db.query(sql, params);
} catch (error) {
  // Add context and rethrow
  throw new DatabaseError(`Query failed: ${sql}`, { cause: error });
}
// The caller sees a meaningful DatabaseError with the original cause attached

const dbError = new Error("Query failed", { cause: originalError });
console.log(dbError.cause); // The original database error
console.log(dbError.cause.stack); // Original stack trace

// Base application error
class AppError extends Error {
  constructor(message, options = {}) {
    super(message, options);
    this.name = this.constructor.name; // "AppError"
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, this.constructor); // V8 optimization
    }
  }
}
 
// Domain-specific errors
class ValidationError extends AppError {
  constructor(message, field) {
    super(message);
    this.field = field;
  }
}
 
class NetworkError extends AppError {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
  }
}
 
class NotFoundError extends AppError {
  constructor(resource, id) {
    super(`${resource} with id ${id} not found`);
    this.resource = resource;
    this.id = id;
  }
}
 
// Usage
try {
  validate(input);
  await save(data);
} catch (err) {
  if (err instanceof ValidationError) {
    return res.status(400).json({ error: err.message, field: err.field });
  }
  if (err instanceof NotFoundError) {
    return res.status(404).json({ error: err.message });
  }
  if (err instanceof NetworkError) {
    return res.status(502).json({ error: "Upstream service unavailable" });
  }
  // Unknown error: 500
  logError(err);
  return res.status(500).json({ error: "Internal server error" });
}

// Browser: uncaught synchronous errors
window.onerror = function (message, source, lineno, colno, error) {
  logToServer({
    type: "uncaught_error",
    message,
    source,
    line: lineno,
    stack: error?.stack,
  });
  return false; // false = let browser show default error, true = suppress
};
 
// Browser: unhandled Promise rejections
window.addEventListener("unhandledrejection", (event) => {
  logToServer({
    type: "unhandled_rejection",
    reason: event.reason?.message || String(event.reason),
    stack: event.reason?.stack,
  });
});
 
// Node.js equivalents:
process.on("uncaughtException", (error) => {
  logger.fatal(error);
  process.exit(1); // Always exit after uncaughtException
});
 
process.on("unhandledRejection", (reason, promise) => {
  logger.error("Unhandled rejection:", reason);
  // Consider process.exit(1) in production
});

// WRONG: Error properties are non-enumerable
console.log(JSON.stringify(new Error("oops"))); // "{}"
 
// CORRECT: explicitly serialize fields
function serializeError(error) {
  return {
    name: error.name,
    message: error.message,
    stack: error.stack,
    cause: error.cause ? serializeError(error.cause) : undefined,
    // Custom fields from AppError subclasses:
    ...(error.field && { field: error.field }),
    ...(error.statusCode && { statusCode: error.statusCode }),
  };
}
 
logToServer(serializeError(error));

async function loadData(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new NetworkError(`HTTP ${response.status}`, response.status);
    }
    return await response.json();
  } catch (err) {
    if (err instanceof NetworkError && err.statusCode === 404) {
      return null; // Graceful not-found
    }
    throw err; // Rethrow everything else
  }
}