higher order functions

Author: adityaSrivastava29

HigherOrderFunction/index.js

@@ -24,6 +24,8 @@ function multiplier(factor) {
 }
 
 const double = multiplier(2);
+console.log(double); // Output: [Function: anonymous]
+// Using the returned function  
 console.log(double(5)); // Output: 10
 
 // 2. Why use Higher Order Functions?

JS-Interview-Questions/HigherOrderFunction.md

@@ -25,28 +25,41 @@ y(); // Hi
 
 ## Examples
 
-### 1. Passing a function as an argument
+### 1. Passing a Function as an Argument
+
 ```js
 function greet(name) {
     return `Hello, ${name}!`;
 }
+
 function processUserInput(callback) {
     const name = 'Aditya';
     return callback(name);
 }
+
 console.log(processUserInput(greet)); // Output: Hello, Aditya!
 ```
+**Explanation:**  
+Here, `processUserInput` is a higher order function because it takes another function (`callback`) as an argument. You pass the `greet` function to it, so `processUserInput` calls `greet` with the name "Aditya". This is a common pattern for handling user input, events, or callbacks.
+
+---
+
+### 2. Returning a Function (Closure)
 
-### 2. Returning a function
 ```js
 function multiplier(factor) {
     return function(number) {
         return number * factor;
     };
 }
+
 const double = multiplier(2);
 console.log(double(5)); // Output: 10
 ```
+**Explanation:**  
+`multiplier` is a higher order function because it returns a new function. When you call `multiplier(2)`, you get a function that multiplies any number by 2. This is called a closure, because the returned function "remembers" the value of `factor`. So, `double(5)` gives you `10`.
+
+---
 
 ### 3. Built-in Higher Order Functions
 There are various built in HOFs, and some of the most common ones are map(), filter() and reduce().
@@ -75,6 +88,8 @@ function repeat(n, action) {
 // Here, console.log is passed as the action, so it logs 0, 1, 2
 repeat(3, console.log); // Logs 0, 1, 2
 ```
+**Explanation:**
+The `repeat` function is a higher order function because it takes another function (`action`) as an argument. You can pass any function to `repeat`, and it will call that function for each number from 0 to n-1. In this example, we pass `console.log`, so it prints 0, 1, and 2.
 
 ### 5. Returning Functions (Closures)
 ```js
@@ -92,6 +107,8 @@ console.log(counter()); // 1
 console.log(counter()); // 2
 // Each call to counter() increases and returns the count
 ```
+**Explanation:**
+`makeCounter` is a higher order function because it returns a new function. The returned function "remembers" the value of `count` even after `makeCounter` has finished running. This is called a closure. Each time you call `counter()`, it increases and returns the count, keeping track of how many times it was called.
 
 ### 6. Function Composition
 ```js
@@ -107,6 +124,8 @@ const add1ThenTimes2 = compose(times2, add1);
 console.log(add1ThenTimes2(5)); // (5 + 1) * 2 = 12
 // add1ThenTimes2 first adds 1 to 5, then multiplies the result by 2
 ```
+**Explanation:**
+The `compose` function is a higher order function because it takes two functions as arguments and returns a new function. The returned function applies `g` to its input, then applies `f` to the result. In the example, `add1ThenTimes2(5)` first adds 1 to 5 (getting 6), then multiplies by 2 (getting 12).
 
 ## Interview Approach Example: Calculating Area and Circumference
 
@@ -131,6 +150,8 @@ const calculateCircumference = function (radius) {
 };
 console.log(calculateCircumference(radius));
 ```
+**Explanation:**
+This approach works, but it repeats similar logic for area and circumference. If you need to add more calculations, you would have to write more similar functions, which is not efficient and violates the DRY (Don't Repeat Yourself) principle.
 
 ### Better Approach Using Higher Order Function
 ```js
@@ -165,6 +186,8 @@ const circumferences = radiusArr.map(circumference);
 console.log(circumferences);    
 
 ```
+**Explanation:**
+Here, we use a higher order function `calculate` that takes an array and a function (`operation`) as arguments. This makes the code reusable and clean. You can pass any calculation logic (like area or circumference) to `calculate`, and it will apply that logic to each element in the array. This is the power of higher order functions and functional programming.
 
 ### Polyfill of map (Custom Implementation)
 ```js
@@ -180,6 +203,8 @@ Array.prototype.calculate = function(operation) {
 }
 console.log(radiusArr.calculate(area));
 ```
+**Explanation:**
+This is a custom implementation (polyfill) of the built-in `map` function. By adding `calculate` to `Array.prototype`, you can use it on any array just like `map`. It takes a function as an argument and applies it to every element in the array, returning a new array with the results.
 
 ## Summary
 Higher order functions are a key concept in JavaScript, enabling powerful patterns for abstraction, reusability, and functional programming.