Closures & Callback Functions

Example demonstrating closures and callback functions:

// Closure example: function retains access to outer scope variables
function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}
const counter = createCounter();

console.log(counter()); // 1
console.log(counter()); // 2

// Callback function example: executed after a delay
function greet(name, callback) {
  console.log('Hello, ' + name + '!');
  callback();
}

greet('Basha Ram', function() {
  console.log('This is a callback function executing after greeting.');
});
          

This code demonstrates:

• How closures preserve access to variables from the outer scope even after the outer function has finished execution.
• Using functions as arguments (callbacks) to enable deferred or asynchronous code execution.
• Practical use of callbacks for sequencing code operations.
• Creating private state using closures for data encapsulation.

Closures: A closure occurs when a function retains access to its lexical scope even when executed outside of that scope. This allows functions to maintain private variables and state.

Callback Functions: These are functions passed as arguments to other functions, which are then invoked (called back) at a certain point in time, often after an asynchronous operation or event.

• Closures enable data privacy and function factories.
• Callbacks are essential for asynchronous programming, event handling, and custom control flows.
• Improves modularity and flexibility in code design.

• Creating private variables and encapsulation in modules.
• Handling asynchronous operations like API calls and timers.
• Building event-driven architectures with callbacks and closures.
• Implementing higher-order functions and function factories.
• Managing state in UI components and frameworks.