How can you create a private counter using closures? Closures से private counter कैसे बनाएं?

A private counter uses a closure to hide the counter variable from the global scope while providing methods to interact with it.

// Simple private counter
function createCounter() {
    let count = 0; // Private variable
    
    return {
        increment: function() {
            return ++count;
        },
        decrement: function() {
            return --count;
        },
        getCount: function() {
            return count;
        }
    };
}

const counter = createCounter();

console.log(counter.increment()); // 1
console.log(counter.increment()); // 2
console.log(counter.decrement()); // 1
console.log(counter.getCount());  // 1

// count is private
console.log(counter.count); // undefined

// Multiple independent counters
const counter1 = createCounter();
const counter2 = createCounter();

counter1.increment();
counter1.increment();
counter2.increment();

console.log(counter1.getCount()); // 2
console.log(counter2.getCount()); // 1 - independent counters!

// Advanced: Counter with step
function createStepCounter(step = 1) {
    let count = 0;
    
    return {
        increment: () => (count += step),
        decrement: () => (count -= step),
        reset: () => (count = 0),
        getCount: () => count,
        setStep: (newStep) => (step = newStep)
    };
}

const stepCounter = createStepCounter(5);
console.log(stepCounter.increment()); // 5
console.log(stepCounter.increment()); // 10
stepCounter.setStep(10);
console.log(stepCounter.increment()); // 20

// Counter with callback on change
function createObservableCounter(onChangeCallback) {
    let count = 0;
    
    return {
        increment: () => {
            count++;
            onChangeCallback(count);
            return count;
        },
        decrement: () => {
            count--;
            onChangeCallback(count);
            return count;
        },
        getCount: () => count
    };
}

const observableCounter = createObservableCounter(function(newCount) {
    console.log(`Counter changed to: ${newCount}`);
});

observableCounter.increment(); // Counter changed to: 1
observableCounter.increment(); // Counter changed to: 2
observableCounter.decrement(); // Counter changed to: 1

// Using arrow functions
const arrowCounter = (() => {
    let count = 0;
    return {
        inc: () => ++count,
        dec: () => --count,
        get: () => count
    };
})();

console.log(arrowCounter.inc()); // 1

// Counter with min/max bounds
function createBoundedCounter(min = 0, max = 10) {
    let count = min;
    
    return {
        increment: () => {
            if (count < max) count++;
            return count;
        },
        decrement: () => {
            if (count > min) count--;
            return count;
        },
        getCount: () => count,
        getRange: () => ({ min, max })
    };
}

const boundedCounter = createBoundedCounter(0, 5);
console.log(boundedCounter.increment()); // 1
console.log(boundedCounter.increment()); // 2
// ... increments up to 5
console.log(boundedCounter.increment()); // 5 (max reached)
console.log(boundedCounter.increment()); // 5 (stays at max)

Interview tip: Emphasize that the counter variable is completely private - there's no way to access or modify it directly from outside the function. This is data encapsulation at its finest. Discuss how each call to createCounter() creates a new independent counter with its own private state. This is a practical and common use of closures.