**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. 

Javascript

Closure Fundamentals

**Higher-order functions** are functions that take other functions as arguments or return functions, enabling more flexible and reusable code by allowing behavior and data to be passed in dynamically.

## Why Use Higher-Order Functions?
- **Abstraction**: Hide away implementation details and focus on what needs to be done.
-  **Reusability**: Create flexible functions that work with different operations.
-  **Cleaner Code**: Avoid repetitive logic and use declarative constructs.

```js
// Higher-order function: accepts a function as an argument
function letPerson(person, fn) {
  return fn(person); // Executes the behavior (fn) with the person data
}

// Behavior function 1: authentication based on role
function authenticate(person) {
  const delay = person.level === 'admin' ? 500000 : 100000;
  for (let i = 0; i < delay; i++) {
    // Simulated heavy computation (authentication)
  }
  return `Access granted to ${person.name}`;
}

// Behavior function 2: introduce person
function introducePerson(person) {
  return `Hi! My name is ${person.name}`;
}

// Example persons
const user = { name: 'Valentin', level: 'user' };
const admin = { name: 'Marko', level: 'admin' };

// Usage examples
console.log(letPerson(user, authenticate)); // Access granted to Valentin
console.log(letPerson(admin, authenticate)); // Access granted to Marko
console.log(letPerson(user, sing)); // La la la... my name is Valentin


```

**This example illustrates:**

 **1.Abstraction:**
- The function **letPerson** abstracts away the details of how the behavior (authentication, introducing, etc.) is performed.
- The caller just needs to provide the behavior function (**fn**) and the person object. **letPerson** does not care what the behavior is internally.
- This hides the implementation details of specific actions and focuses on the “what” — applying some behavior to a person.


 **2.Reusability:**
 
 - The higher-order function **letPerson** that works with any behavior function you pass in.
 - This allows you to reuse the same **letPerson** function for different operations (authenticate, introducePerson, or any other behavior you want to add later).
 - The behavior functions themselves (authenticate, introducePerson) are modular and reusable for different person objects.

 **3.Cleaner Code:**
 - Instead of writing separate functions that manually handle the person object and execute their logic, you use a declarative, functional approach.
 -  Avoid repeating the code structure for passing the person and executing the behavior.
 -  The logic for each behavior is separated, clear, and easy to maintain.
 

Higher Order Functions in Javascript

How to write cleaner, more reusable and more expressive Javascript code using Higher Order Functions

Functional programming

Closures in Javascript

Higher Order Functions in Javascript