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

Function abstraction

Higher Order Functions in Javascript