Introduction

A callback function is a function that is passed as an argument to another function and is executed later by that function. Callback functions are one of the most fundamental concepts in JavaScript and are widely used for handling asynchronous operations, event handling, array methods, timers, and API requests.

Callbacks allow developers to write flexible and reusable code by separating what should happen from when it should happen.

For automation engineers, callback functions are extensively used in Playwright, Cypress, Selenium (JavaScript), API testing, event handling, asynchronous operations, and reusable utility methods.

What is a Callback Function?

A callback function is simply a function that is passed to another function and is called when needed.

Example:

function greet() {

    console.log("Hello!");

}

function execute(callback) {

    callback();

}

execute(greet);

Output

Hello!

Here:

greet() is the callback function.
execute() is the function that receives and executes the callback.

Why Use Callback Functions?

Callbacks help you:

Reuse code.
Execute functions at the right time.
Handle asynchronous operations.
Write modular programs.
Avoid duplicate code.

Syntax

function mainFunction(callback) {

    callback();

}

function callbackFunction() {

    // Code

}

mainFunction(callbackFunction);

Example 1: Basic Callback Function

function welcome() {

    console.log("Welcome!");

}

function display(callback) {

    callback();

}

display(welcome);

Output

Welcome!

Example 2: Callback with Parameters

function greet(name) {

    console.log("Hello " + name);

}

function execute(callback) {

    callback("Alice");

}

execute(greet);

Output

Hello Alice

Example 3: Anonymous Callback Function

function execute(callback) {

    callback();

}

execute(function () {

    console.log("Anonymous Callback");

});

Output

Anonymous Callback

Example 4: Arrow Function Callback

function execute(callback) {

    callback();

}

execute(() => {

    console.log("Arrow Callback");

});

Output

Arrow Callback

Example 5: Calculator Using Callbacks

function calculate(a, b, operation) {

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

}

function add(x, y) {

    return x + y;

}

calculate(10, 20, add);

Output

By changing the callback function, the same calculator can perform different operations.

Callback Functions with `setTimeout()`

Callbacks are frequently used with timers.

setTimeout(() => {

    console.log("Executed after 2 seconds");

}, 2000);

Output

Executed after 2 seconds

The callback executes after the specified delay.

Callback Functions with Array Methods

const numbers = [1, 2, 3, 4];

numbers.forEach(number => {

    console.log(number);

});

Output

The arrow function passed to forEach() is a callback.

Real-World Example

Process an order and send a confirmation.

function processOrder(callback) {

    console.log("Order Processed");

    callback();

}

function sendConfirmation() {

    console.log("Confirmation Sent");

}

processOrder(sendConfirmation);

Output

Order Processed
Confirmation Sent

Another example:

Generate a report.

function generateReport(callback) {

    console.log("Preparing Report");

    callback();

}

generateReport(() => {

    console.log("Report Generated");

});

Output

Preparing Report
Report Generated

Automation Testing Example

Callbacks are commonly used in automation frameworks for reusable test execution.

Playwright Example

function runTest(callback) {

    console.log("Starting Test");

    callback();

}

runTest(() => {

    console.log("Launching Chromium");

});

Output

Starting Test
Launching Chromium

Selenium Example

function executeStep(callback) {

    callback();

}

function openApplication() {

    console.log("Opening Application");

}

executeStep(openApplication);

Output

Opening Application

Cypress Example

function execute(callback) {

    callback("Login Test");

}

execute(testName => {

    console.log("Executing " + testName);

});

Output

Executing Login Test

API Testing Example

function validateResponse(callback) {

    callback(200);

}

validateResponse(statusCode => {

    console.log(statusCode === 200);

});

Output

true

Data-Driven Testing Example

function processUser(callback) {

    callback("admin");

}

processUser(username => {

    console.log(username);

});

Output

admin

Synchronous vs Asynchronous Callbacks

Synchronous Callback	Asynchronous Callback
Executes immediately	Executes later
Used in `forEach()`	Used in `setTimeout()`
Blocks execution until complete	Runs after a delay or event
Simpler execution flow	Useful for non-blocking operations

Common Uses of Callback Functions

Callbacks are widely used in:

Event listeners
setTimeout()
setInterval()
Array methods (map(), filter(), find(), reduce(), forEach())
API requests
File operations
Promises (internally)
Automation testing frameworks

Common Mistakes

Calling the Callback Immediately

Incorrect:

execute(greet());

Correct:

execute(greet);

Using parentheses executes the function immediately instead of passing it.

Forgetting to Execute the Callback

function execute(callback) {

}

The callback is received but never called.

Correct:

function execute(callback) {

    callback();

}

Passing a Non-Function

execute(100);

This results in an error because 100 is not a function.

Best Practices

Use Meaningful Callback Names

Examples:

callback
handler
processor
validator
onSuccess

Prefer Arrow Functions for Short Callbacks

Arrow functions make callbacks concise and readable.

Keep Callbacks Focused

Each callback should perform one specific task.

Validate Callback Arguments

Before executing a callback, verify that it is a function.

function execute(callback) {

    if (typeof callback === "function") {

        callback();

    }

}

Conclusion

Callback functions are a fundamental part of JavaScript programming. They allow one function to pass control to another function, making programs more modular, reusable, and flexible.

Callbacks are widely used in asynchronous programming, event handling, timers, array methods, API requests, and automation frameworks.

For automation engineers, understanding callback functions is essential for writing reusable Playwright scripts, Selenium utilities, Cypress commands, API handlers, and scalable automation frameworks.

Frequently Asked Questions (FAQs)