Error Handling

The try/catch/finally statement handles exceptions and cleanup operations.

Basic Syntax

try {
  // Code that might throw an error
  const result = riskyOperation();
} catch (error) {
  // Handle the error
  console.error('Error:', error.message);
} finally {
  // Always runs, regardless of success or failure
  cleanup();
}

Without catch or finally

// try with finally (no catch)
try {
  doSomething();
} finally {
  cleanup(); // Runs even if doSomething throws
}

// try with catch (no finally)
try {
  doSomething();
} catch (error) {
  handleError(error);
}

Error Object Properties

try {
  riskyOperation();
} catch (error) {
  console.log(error.name);     // 'TypeError', 'ReferenceError', etc.
  console.log(error.message);  // Human-readable description
  console.log(error.stack);    // Stack trace
}

Nested try/catch

try {
  try {
    operation1();
  } catch (error) {
    console.log('Operation 1 failed:', error);
    operation2();
  }
} catch (error) {
  console.log('Operation 2 failed:', error);
}

You can create custom error types for better error handling and debugging.

Creating Custom Errors

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

// Usage
function validateAge(age) {
  if (age < 0 || age > 150) {
    throw new ValidationError('Invalid age', 'age');
  }
  return age;
}

try {
  validateAge(200);
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(`${error.field}: ${error.message}`);
  }
}

Common Custom Errors

// API Error
class ApiError extends Error {
  constructor(message, statusCode, data) {
    super(message);
    this.name = 'ApiError';
    this.statusCode = statusCode;
    this.data = data;
  }
}

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

// Authentication Error
class AuthError extends Error {
  constructor(message = 'Authentication required') {
    super(message);
    this.name = 'AuthError';
  }
}

Error Handling by Type

try {
  // Some operation
} catch (error) {
  if (error instanceof ValidationError) {
    // Handle validation
  } else if (error instanceof ApiError) {
    // Handle API error
  } else if (error instanceof TypeError) {
    // Handle type error
  } else {
    // Handle unknown errors
    console.error('Unexpected error:', error);
  }
}

Errors propagate up the call stack until caught. Understanding this helps write robust code.

How Errors Propagate

function outer() {
  inner(); // Error from inner propagates here
}

function inner() {
  middle(); // Error from middle propagates here
}

function middle() {
  throw new Error('Something went wrong');
}

try {
  outer(); // Caught here
} catch (error) {
  console.error(error.message); // 'Something went wrong'
}

Re-throwing Errors

function processData(data) {
  try {
    validateData(data);
    return transform(data);
  } catch (error) {
    console.log('Processing failed:', error.message);
    throw error; // Re-throw for caller to handle
  }
}

Error Handling in Async Code

// Promise chain
fetchData()
  .then(process)
  .catch(handleError); // Catches errors from any step

// Async/await
async function main() {
  try {
    const data = await fetchData();
    const result = await process(data);
    return result;
  } catch (error) {
    handleError(error);
  }
}

Best Practices

// 1. Always provide context
throw new Error(`Failed to process user ${userId}: ${originalError.message}`);

// 2. Use specific error types
throw new ValidationError('Email is required', 'email');

// 3. Don't swallow errors silently
try {
  riskyOperation();
} catch (error) {
  console.error(error); // At minimum, log it
}

// 4. Clean up in finally
try {
  const resource = acquireResource();
  useResource(resource);
} finally {
  releaseResource(); // Always cleanup
}