Introduction

Callback functions are one of the fundamental building blocks of JavaScript and Node.js. They allow one function to execute another function after completing a task. Callbacks are used in both synchronous and asynchronous programming and are essential for handling events, timers, file operations, API requests, database queries, and user interactions.

Although modern JavaScript often uses Promises and async/await for complex asynchronous workflows, callback functions are still widely used in Node.js APIs and automation frameworks.

For automation engineers, callbacks are frequently used for browser automation, file handling, API testing, test data processing, event handling, logging, reporting, and asynchronous execution.

In this tutorial, you’ll explore several practical examples of callback functions in Node.js.

Why Use Callback Functions?

Callback functions help developers:

Execute code after a task completes.
Handle asynchronous operations.
Improve code reusability.
Separate business logic.
Respond to events.
Simplify data processing.
Build modular applications.

Example 1: Greeting Callback

Execute a callback after displaying a greeting.

function greet(name, callback) {

    console.log(
        "Hello " + name
    );

    callback();

}

function completed() {

    console.log(
        "Greeting completed."
    );

}

greet(
    "Rahul",
    completed
);

Sample Output

Hello Rahul
Greeting completed.

Example 2: Calculator Callback

Perform different mathematical operations using callbacks.

function calculate(a, b, operation) {

    console.log(
        operation(a, b)
    );

}

function multiply(x, y) {

    return x * y;

}

calculate(
    5,
    6,
    multiply
);

Sample Output

Example 3: Timer Callback

Execute a callback after a delay.

console.log("Start");

setTimeout(function () {

    console.log(
        "Timer finished."
    );

}, 2000);

console.log("End");

Sample Output

Start
End
Timer finished.

Example 4: File Reading Callback

Read a file asynchronously.

const fs =
    require("fs");

fs.readFile(
    "sample.txt",
    "utf8",
    function (error, data) {

        if (error) {

            console.log(error);

            return;

        }

        console.log(data);

    }
);

The callback executes after the file has been read.

Example 5: Error-First Callback

Handle errors using the Node.js callback pattern.

function getUser(callback) {

    const error = null;

    const user =
        "Rahul";

    callback(error, user);

}

getUser(function (error, user) {

    if (error) {

        console.log(error);

        return;

    }

    console.log(user);

});

Sample Output

Rahul

Automation Testing Examples

Callbacks are commonly used in automation frameworks for handling asynchronous tasks.

Playwright Example

Execute tests after page loading.

function loadPage(callback) {

    console.log(
        "Loading page..."
    );

    callback();

}

loadPage(function () {

    console.log(
        "Execute Playwright test."
    );

});

Sample Output

Loading page...
Execute Playwright test.

Selenium Example

Run tests after browser launch.

function launchBrowser(callback) {

    console.log(
        "Launching browser..."
    );

    callback();

}

launchBrowser(function () {

    console.log(
        "Run Selenium test."
    );

});

Sample Output

Launching browser...
Run Selenium test.

Cypress Example

Validate elements after visiting a page.

function visitApplication(callback) {

    console.log(
        "Opening application..."
    );

    callback();

}

visitApplication(function () {

    console.log(
        "Validate UI elements."
    );

});

Sample Output

Opening application...
Validate UI elements.

API Testing Example

Handle API response processing.

function requestApi(callback) {

    console.log(
        "Sending API request..."
    );

    callback();

}

requestApi(function () {

    console.log(
        "Validate API response."
    );

});

Sample Output

Sending API request...
Validate API response.

Data-Driven Testing Example

Process test data after loading.

function loadData(callback) {

    console.log(
        "Loading CSV data..."
    );

    callback();

}

loadData(function () {

    console.log(
        "Execute data-driven tests."
    );

});

Sample Output

Loading CSV data...
Execute data-driven tests.

Real-World Uses of Callback Functions

Callbacks are commonly used for:

Reading files.
Writing files.
API requests.
Database operations.
Browser automation.
Event handling.
Timers.
User input processing.
Logging.
Report generation.

Common Mistakes

Calling the Callback Instead of Passing It

Incorrect:

execute(callback());

Correct:

execute(callback);

Ignoring Errors

Always handle errors when using Node.js error-first callbacks.

Creating Callback Hell

Deeply nested callbacks make code difficult to maintain. Use Promises or async/await when appropriate.

Best Practices

Keep callback functions small.
Use meaningful function names.
Handle errors properly.
Avoid excessive callback nesting.
Reuse callback functions whenever possible.
Separate business logic from callback logic.
Use Promises or async/await for complex asynchronous workflows.

Conclusion

Callback functions remain an essential part of JavaScript and Node.js programming. They enable functions to execute after a task completes and provide the foundation for asynchronous programming.

For automation engineers, callbacks are widely used in browser automation, API testing, file handling, database interactions, timers, and event-driven programming. Understanding practical callback examples will help you write cleaner, more modular, and more efficient Node.js automation frameworks.

Frequently Asked Questions (FAQs)

What is a callback function?

A callback function is a function passed as an argument to another function and executed later.

Why are callbacks important?

They allow code to execute after synchronous or asynchronous operations complete.

Where are callbacks commonly used?

Callbacks are used in timers, file handling, API requests, database operations, and event handling.

What is callback hell?

Callback hell is excessive nesting of callback functions, making code difficult to read and maintain.

Should I always use callbacks?

Callbacks are useful for many situations, but Promises and async/await are generally preferred for managing complex asynchronous code.

Key Takeaways

Callback functions are passed as arguments to other functions.
They execute after a task or event completes.
Callbacks support both synchronous and asynchronous programming.
Node.js APIs commonly use callbacks.
Error-first callbacks are a standard Node.js pattern.
Automation frameworks use callbacks for browser automation, API testing, and file handling.
Keep callback functions simple and reusable.
Avoid deeply nested callbacks.
Promises and async/await provide cleaner alternatives for complex asynchronous workflows.
Understanding callbacks is essential for mastering advanced JavaScript and Node.js.