How do you handle errors in JavaScript? Explain try/catch/finally and how to handle async errors.

Question

Accepted Answer

## Basic Error Handling: try/catch/finally

```javascript
try {
  // Code that might throw an error
  const result = riskyOperation();
  console.log(result);
} catch (error) {
  // Handle the error
  console.error("Something went wrong:", error.message);
} finally {
  // Always runs, regardless of error
  cleanup();
}
```

### The Error Object

```javascript
try {
  throw new Error("Something failed");
} catch (error) {
  console.log(error.name);     // "Error"
  console.log(error.message);  // "Something failed"
  console.log(error.stack);    // Stack trace
}
```

## Async Error Handling

### With Promises (.catch)

```javascript
fetchData()
  .then(data => processData(data))
  .then(result => console.log(result))
  .catch(error => console.error("Error:", error));
```

### With async/await (try/catch)

```javascript
async function getData() {
  try {
    const response = await fetch("/api/data");
    if (!response.ok) {
      throw new Error(`HTTP error: ${response.status}`);
    }
    const data = await response.json();
    return data;
  } catch (error) {
    console.error("Failed to fetch:", error);
    throw error;  // Re-throw if caller should handle it
  }
}
```

## Custom Error Classes

```javascript
class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = "ValidationError";
    this.field = field;
  }
}

// Usage
try {
  throw new ValidationError("Email is invalid", "email");
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(`Field ${error.field}: ${error.message}`);
  }
}
```

## Best Practices

| Practice | Description |
|----------|-------------|
| **Be specific** | Catch specific error types when possible |
| **Don't swallow errors** | Always log or re-throw |
| **Use finally for cleanup** | Close connections, clear timers |
| **Validate inputs early** | Fail fast with clear messages |
| **Centralize handling** | Use error middleware in backends |

## Common Pattern: Wrapper Function

```javascript
// Utility to handle async errors cleanly
async function tryCatch(promise) {
  try {
    const data = await promise;
    return [data, null];
  } catch (error) {
    return [null, error];
  }
}

// Usage
const [user, error] = await tryCatch(fetchUser(id));
if (error) {
  // handle error
}
```