**Closures in JavaScript** are created when a function retains access to variables from its lexical scope, even after the outer function has finished executing. This allows **inner functions to "remember"** variables from their parent scopes

**Example:**
```js
function outer() {
  const message = "Hello from the outer scope!";
  return function inner() {
    console.log(message); // still has access to `message`
  };
}

const greet = outer(); 
greet(); // Output: "Hello from the outer scope!"

```



## Why are closures useful?

**1.Closures  Encapsulate Data and Avoids Global Scope Pollution**
 By creating variables inside a function and exposing only selected methods to interact with them, you avoid putting those variables in the global scope. This means:

-  **don’t pollute the global namespace** with variables that could conflict with others.
-   **avoid name collisions**
- **control access** to your variables, preventing unintended modification from outside code.

```js
function createUser(name) {
  let loginCount = 0; // private variable

  return {
    getName() {
      return name;
    },
    login() {
      loginCount++;
      console.log(`${name} has logged in ${loginCount} times`);
    }
  };
}

const user1 = createUser("Alice");
user1.login(); // Alice has logged in 1 times
user1.login(); // Alice has logged in 2 times

console.log(user1.loginCount); // undefined – it's private!
```

**2.Function Factories**

Function factories return customized functions based on input.

```js
function makeMultiplier(factor) {
  return function(number) {
    return number * factor;
  };
}

const double = makeMultiplier(2);
const triple = makeMultiplier(3);

console.log(double(5)); // 10
console.log(triple(5)); // 15
```

**3.Persistent Data Storage (Private State)**

Closures allow you to store and access private data that persists across function calls.

```js
function createCounter() {
  let count = 0;

  return {
    increment() {
      count++;
      console.log(count);
    },
    decrement() {
      count--;
      console.log(count);
    },
    getValue() {
      return count;
    }
  };
}

const counter = createCounter();
counter.increment(); // 1
counter.increment(); // 2
console.log(counter.getValue()); // 2
```
**4.Delayed Execution**

Closures preserve data for use in asynchronous operations, such as timers or events.

```js
function delayedGreeting(name) {
  setTimeout(function() {
    console.log(`Hello, ${name}!`);
  }, 1000);
}

delayedGreeting("Alice"); // Outputs "Hello, Alice!" after 1 second

```



Closures in Javascript

The concept of closures in JavaScript, how closures work and why they’re essential for writing effective, modern JavaScript. 