Understanding Callbacks

Callbacks are the foundation of asynchronous programming in Node.js. Before Promises and async/await, callbacks were the primary way to handle operations that take time, like reading files or making network requests. Understanding callbacks is essential for working with Node.js.

---

What is a Callback?

A callback is a function passed as an argument to another function, to be executed later when an operation completes:

function greet(name, callback) {
  const message = `Hello, ${name}!`;
  callback(message);
}

greet('Alice', function(result) {
  console.log(result);  // "Hello, Alice!"
});

In this example:

1. We pass an anonymous function as the second argument
2. greet does its work and then calls our function with the result
3. Our callback receives the result and does something with it

---

Why Callbacks?

JavaScript is single-threaded but needs to handle operations that take time:

• Reading files from disk
• Making HTTP requests
• Querying databases
• Waiting for user input

Instead of blocking and waiting, Node.js uses callbacks to continue executing other code and get notified when the operation completes.

const fs = require('fs');

console.log('Starting...');

fs.readFile('file.txt', 'utf8', (err, data) => {
  console.log('File contents:', data);
});

console.log('This runs while file is being read!');

Output order:

Starting...
This runs while file is being read!
File contents: (actual file contents)

---

Synchronous vs Asynchronous

// Synchronous - blocks execution
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data);  // Must wait for file read
console.log('Done');

// Asynchronous - doesn't block
fs.readFile('file.txt', 'utf8', (err, data) => {
  console.log(data);  // Runs when file is ready
});
console.log('Done');  // Runs immediately

---

Error-First Callbacks

Node.js uses a convention called "error-first callbacks" where the first parameter is always an error (or null if no error):

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error:', err.message);
    return;
  }
  console.log('Data:', data);
});

This pattern ensures you always handle errors:

1. Check if err exists
2. If error, handle it and return early
3. If no error, proceed with the data

---

Common Callback Patterns

1. Processing Arrays with Callbacks

function processItems(items, processor, done) {
  const results = [];
  let completed = 0;

  items.forEach((item, index) => {
    processor(item, (err, result) => {
      if (err) return done(err);
      results[index] = result;
      completed++;
      if (completed === items.length) {
        done(null, results);
      }
    });
  });
}

2. Sequential Operations

function step1(callback) {
  setTimeout(() => callback(null, 'Step 1 done'), 100);
}

function step2(data, callback) {
  setTimeout(() => callback(null, data + ' -> Step 2 done'), 100);
}

function step3(data, callback) {
  setTimeout(() => callback(null, data + ' -> Step 3 done'), 100);
}

// Run in sequence
step1((err, result1) => {
  step2(result1, (err, result2) => {
    step3(result2, (err, result3) => {
      console.log(result3);
    });
  });
});

---

Callback Hell (The Pyramid of Doom)

When callbacks are nested too deeply, code becomes hard to read and maintain:

getUser(userId, (err, user) => {
  if (err) return handleError(err);
  getOrders(user.id, (err, orders) => {
    if (err) return handleError(err);
    getOrderDetails(orders[0].id, (err, details) => {
      if (err) return handleError(err);
      getShippingInfo(details.shipmentId, (err, shipping) => {
        if (err) return handleError(err);
        getTrackingInfo(shipping.trackingId, (err, tracking) => {
          if (err) return handleError(err);
          console.log('Tracking:', tracking);
        });
      });
    });
  });
});

This is called "callback hell" because:

• Code moves increasingly to the right
• Hard to follow the logic
• Error handling is repetitive
• Difficult to maintain

---

Avoiding Callback Hell

1. Named Functions

Extract callbacks into named functions:

function handleTracking(err, tracking) {
  if (err) return handleError(err);
  console.log('Tracking:', tracking);
}

function handleShipping(err, shipping) {
  if (err) return handleError(err);
  getTrackingInfo(shipping.trackingId, handleTracking);
}

function handleDetails(err, details) {
  if (err) return handleError(err);
  getShippingInfo(details.shipmentId, handleShipping);
}

// Much flatter!
getOrderDetails(orderId, handleDetails);

2. Early Returns

Always return after error handling to prevent continued execution:

function processData(data, callback) {
  if (!data) {
    return callback(new Error('No data provided'));
  }

  if (typeof data !== 'string') {
    return callback(new Error('Data must be a string'));
  }

  // Process valid data
  callback(null, data.toUpperCase());
}

---

Callbacks in Node.js Core

Many Node.js core modules use callbacks:

const fs = require('fs');
const http = require('http');

// File system
fs.readFile('file.txt', 'utf8', (err, data) => {});
fs.writeFile('file.txt', 'data', (err) => {});
fs.mkdir('dir', (err) => {});

// HTTP
http.get('http://example.com', (response) => {
  response.on('data', (chunk) => {});
  response.on('end', () => {});
});

// Timers
setTimeout(() => {
  console.log('Delayed');
}, 1000);

setInterval(() => {
  console.log('Repeated');
}, 1000);

---

Creating Callback-Based Functions

When creating your own async functions, follow these guidelines:

function fetchData(url, options, callback) {
  // Handle optional parameters
  if (typeof options === 'function') {
    callback = options;
    options = {};
  }

  // Validate inputs
  if (!url) {
    return callback(new Error('URL is required'));
  }

  // Perform async operation
  setTimeout(() => {
    // Simulate success/failure
    if (url.includes('error')) {
      callback(new Error('Failed to fetch'));
    } else {
      callback(null, { data: 'response from ' + url });
    }
  }, 100);
}

// Usage
fetchData('https://api.example.com', (err, data) => {
  if (err) return console.error(err);
  console.log(data);
});

---

Common Mistakes

1. Forgetting to Return After Error

// Wrong - continues execution after error!
function bad(callback) {
  if (error) {
    callback(new Error('Something wrong'));
  }
  // This still runs!
  callback(null, 'success');
}

// Correct
function good(callback) {
  if (error) {
    return callback(new Error('Something wrong'));
  }
  callback(null, 'success');
}

2. Calling Callback Multiple Times

// Wrong - calls callback twice
function bad(items, callback) {
  items.forEach(item => {
    if (item.error) {
      callback(new Error('Bad item'));  // Called multiple times!
    }
  });
  callback(null, 'done');
}

// Correct - use a flag or early return
function good(items, callback) {
  let hasError = false;
  for (const item of items) {
    if (item.error) {
      hasError = true;
      return callback(new Error('Bad item'));
    }
  }
  callback(null, 'done');
}

---

Key Takeaways

• Callbacks are functions passed to other functions for later execution
• Node.js uses error-first callbacks: callback(err, result)
• Always check for errors first and return early
• Callback hell happens with deeply nested callbacks
• Flatten callbacks using named functions
• Never call a callback more than once
• Always return after calling a callback with an error
• Modern Node.js offers Promises and async/await as alternatives

---

Summary

Callbacks are the original asynchronous pattern in Node.js. While they can lead to deeply nested code, understanding them is essential because they're still used throughout the Node.js ecosystem. You've learned the error-first convention, how to avoid callback hell, and common patterns for working with callbacks.

Next, you'll learn about Promises, which provide a cleaner syntax for handling asynchronous operations.