Callback Error Handling in JavaScript

Callback Error Handling in JavaScript

Error handling with callbacks uses the error-first convention (Node.js style). Understanding it is essential for Node.js and callback-based APIs.

The Error-First Convention

The callback's first argument is an error. If there is no error, it is null. The second argument (and beyond) is the result.

fs.readFile("file.txt", (err, data) => {
  if (err) {
    console.error("Error:", err);
    return;
  }
  console.log("Data:", data);
});
``
### Always Check for the Error First

```js
// good: check err first
fetchUser(id, (err, user) => {
  if (err) { handleError(err); return; }
  render(user);
});

// bad: ignoring err (user might be undefined)
fetchUser(id, (err, user) => {
  render(user); // if err, user is undefined -> TypeError
});
``
### The Error-First Pattern

```js
function myAsyncOperation(arg, callback) {
  setTimeout(() => {
    if (!arg) {
      callback(new Error("arg is required"));
      return;
    }
    callback(null, arg.toUpperCase());
  }, 100);
}
``
When creating your own callback-based APIs, follow the convention: `callback(err, result)`.

### Propagating Errors

```js
fetchUser(id, (err, user) => {
  if (err) { callback(err); return; } // propagate
  fetchPosts(user, (err, posts) => {
    if (err) { callback(err); return; } // propagate
    callback(null, { user, posts });
  });
});
``
Each step checks and propagates the error. This is repetitive (one reason callback hell is bad).

### Promises Are Better for Errors

```js
async function main() {
  try {
    const user = await fetchUserP(id);
    const posts = await fetchPostsP(user);
    return { user, posts };
  } catch (err) {
    handleError(err);
  }
}
``
One `try/catch` handles all errors. Much cleaner than error-first callbacks.

### The Takeaway

Callback error handling uses the error-first convention: `callback(err, result)`. Always check `if (err)` first and return early. Propagate errors to the caller. This is repetitive, which is why promises (with `.catch`) and async/await (with `try/catch`) are better for error handling.