REFERENCEjavascript

javascript Documentation

📖 INDEX

# what-is-javascript

# function-declaration

# function-expressions

# anonymous-functions

# arrow-functions

# return

# recursive-functions

# arguments-parameters

# array-destructuring

# what-is-dom

# element-selection

# selection-methods

# elements-manipulation

# events

# event-listeners

# modification-methods

LOADING ENGINE...

Callback Functions

AI & DATA SCIENCE // callback-functions

A callback is a function passed as an argument to another function, called when an operation completes.

Syntax

setTimeout(() => console.log('done'), 1000);

function process(data, callback) {
  const result = transform(data);
  callback(result);
}

Deep Dive Course

**Callbacks** are the original async pattern in JavaScript. You pass a function to another function to be called when ready. The **Node.js error-first callback convention**: `callback(error, result)` — first argument is error (null if success). Callbacks led to 'callback hell' — deeply nested callbacks. Promises and async/await solved this.

1Understanding Callback Functions

Callbacks are the original async pattern in JavaScript. You pass a function to another function to be called when ready. The Node.js error-first callback convention: callback(error, result) — first argument is error (null if success). Callbacks led to 'callback hell' — deeply nested callbacks. Promises and async/await solved this.

💡

Always handle errors in Node-style callbacks: if (err) { return handleError(err); }

editor.html

// Node.js error-first callback pattern
const fs = require('fs');

fs.readFile('./data.json', 'utf8', (err, data) => {
  if (err) {
    console.error('Failed to read:', err.message);
    return;
  }
  const parsed = JSON.parse(data);
  console.log(parsed);
});

localhost:3000

2Practical Example

Here is a real-world application of Callback Functions showing how it is used in production JavaScript code.

editor.html

// Callback hell vs Promise chain vs async/await
// Callback hell:
getUser(id, (err, user) => {
  getPosts(user.id, (err, posts) => {
    getComments(posts[0].id, (err, comments) => {
      // deeply nested...
    });
  });
});

// async/await (clean)
async function load(id) {
  const user = await getUser(id);
  const posts = await getPosts(user.id);
  return getComments(posts[0].id);
}

localhost:3000

3Best Practices

Follow these guidelines when working with Callback Functions:

1. Follow Node.js convention: callback(error, result)

2. Use Promises or async/await for new code

3. Name callbacks meaningfully: onSuccess, onError, handleData

⚠️

Tip: Always handle errors in Node-style callbacks: if (err) { return handleError(err); }

editor.html

// Node.js error-first callback pattern
const fs = require('fs');

fs.readFile('./data.json', 'utf8', (err, data) => {
  if (err) {
    console.error('Failed to read:', err.message);
    return;
  }
  const parsed = JSON.parse(data);
  console.log(parsed);
});

localhost:3000

Examples

Example 01Basic Usage

// Node.js error-first callback pattern
const fs = require('fs');

fs.readFile('./data.json', 'utf8', (err, data) => {
  if (err) {
    console.error('Failed to read:', err.message);
    return;
  }
  const parsed = JSON.parse(data);
  console.log(parsed);
});

Example 02Advanced Example

// Callback hell vs Promise chain vs async/await
// Callback hell:
getUser(id, (err, user) => {
  getPosts(user.id, (err, posts) => {
    getComments(posts[0].id, (err, comments) => {
      // deeply nested...
    });
  });
});

// async/await (clean)
async function load(id) {
  const user = await getUser(id);
  const posts = await getPosts(user.id);
  return getComments(posts[0].id);
}

Best Practices

Follow Node.js convention: callback(error, result)
Use Promises or async/await for new code
Name callbacks meaningfully: onSuccess, onError, handleData

Interview Question

What is callback hell and how do Promises/async-await solve it?▼

Hint: Nesting depth and error handling.

Callback hell is deeply nested callbacks that make code hard to read, error-prone (each level needs its own error handling), and difficult to maintain. Promises flatten this with .then() chaining. async/await makes it look synchronous — linear, readable, and a single try/catch handles all errors.

Exercises

MediumPractice using Callback Functions in a real scenario.

View Solution

// Node.js error-first callback pattern
const fs = require('fs');

fs.readFile('./data.json', 'utf8', (err, data) => {
  if (err) {
    console.error('Failed to read:', err.message);
    return;
  }
  const parsed = JSON.parse(data);
  console.log(parsed);
});

Frequently Asked Questions

What is callback hell and how do Promises/async-await solve it?▼

Related Functions

PromisesawaitArrow-FunctionsClosures