# Step 1 — Understand Asynchronous Errors

• Node.js uses asynchronous programming for I/O operations

• Errors can happen in:

  • Callbacks (old style)

  • Promises (.then / .catch)

  • Async/Await

• Common symptoms:

  • App crashes unexpectedly

  • Unhandled promise rejection warning

  • Silent failures (no logs)

## Step 2 — Handle Errors in Callbacks

• Old-school Node.js uses error-first callbacks:

const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('File read error:', err);
    return;
  }
  console.log('File content:', data);
});

• Always check the first argument err

• Prevents crashes when asynchronous operations fail

## Step 3 — Handle Errors in Promises

• Promises need .catch() to handle errors:

fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(err => console.error('Promise error:', err));

• Forgetting .catch() leads to unhandled promise rejections

## Step 4 — Handle Errors with Async/Await

• Async/await is cleaner but requires try/catch:

async function getData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
    const data = await response.json();
    console.log(data);
  } catch (err) {
    console.error('Async/await error:', err);
  }
}

getData();

• Wrap each asynchronous block in try/catch to handle errors

## Step 5 — Global Error Handling

• Catch unexpected errors:

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection:', reason);
});

process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err);
  process.exit(1); // optional: restart app safely
});

• Helps prevent app from crashing silently

## Step 6 — Handle Async Errors in Express.js

• Middleware error handling:

const express = require('express');
const app = express();

app.get('/', async (req, res, next) => {
  try {
    const data = await getData();
    res.send(data);
  } catch (err) {
    next(err); // pass error to Express error handler
  }
});

// Express error handler
app.use((err, req, res, next) => {
  console.error('Express error:', err);
  res.status(500).send('Something went wrong!');
});

• Always forward errors to the error-handling middleware

## Step 7 — Avoid Common Mistakes

1. Ignoring errors → leads to silent failures

2. Mixing callbacks and promises without handling → uncaught errors

3. Not validating async data → may throw exceptions

• Always wrap async operations in try/catch or .catch()

## Step 8 — Beginner-Friendly Checklist

## Step 9 — Conclusion

Asynchronous errors are common in Node.js, but beginners can manage them by:

• Checking errors in callbacks

• Using .catch() for promises

• Wrapping async/await in try/catch

• Handling global errors safely

• Using Express middleware for server-side routes

Following these steps ensures your Node.js app runs reliably and handles failures gracefully without crashing.