Merge branch 'main' of https://github.com/adityaSrivastava29/JavaScriptConcepts

Author: adityaSrivastava29

HigherOrderFunction/filter.js

@@ -0,0 +1,30 @@
+// Filter function
+// Filter function is basically used to filter the value inside an array. The arr.filter() method is used to create a new array from a given array consisting of only those elements from the given array which satisfy a condition set by the argument method.
+
+const arr = [5, 1, 3, 2, 6];
+// filter odd values
+function isOdd(x) {
+  return x % 2;
+}
+const oddArr = arr.filter(isOdd); // [5,1,3]
+console.log(oddArr); // Output: [5, 1, 3]
+// Other way of writing the above:
+const oddArrAlt = arr.filter((x) => x % 2);
+console.log(oddArrAlt); // Output: [5, 1, 3]
+
+//pollyfill for filter
+Array.prototype.myFilter = function(callback) {
+  let result = [];
+  for (let i = 0; i < this.length; i++) {
+    if (callback(this[i], i, this)) { // Pass current element, index, and array to the callback
+      result.push(this[i]);
+    }
+  }
+  return result;
+}
+function isEven(x){
+    return x % 2 === 0 ;
+}
+const myEvenArr = arr.myFilter(isEven);
+console.log(myEvenArr); // Output:  [ 2, 6 ]
+

HigherOrderFunction/hof.js

@@ -0,0 +1,135 @@
+
+// Higher Order Functions in JavaScript
+
+// 1. What is a Higher Order Function?
+// A higher order function is a function that either takes one or more functions as arguments, or returns a function as its result.
+
+// Example 1: Passing a function as an argument
+function greet(name) {
+    return `Hello, ${name}!`;
+}
+
+function processUserInput(callback) {
+    const name = 'Aditya';
+    return callback(name);
+}
+
+console.log(processUserInput(greet)); // Output: Hello, Aditya!
+
+// Example 2: Returning a function
+function multiplier(factor) {
+    return function(number) {
+        return number * 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?
+// - Abstraction: Hide details and expose only necessary parts.
+// - Reusability: Write generic functions that work with other functions.
+// - Functional Programming: Enables techniques like map, filter, reduce.
+
+// 3. Built-in Higher Order Functions
+const numbers = [1, 2, 3, 4, 5];
+
+// map: transforms each element
+const squares = numbers.map(x => x * x);
+console.log(squares); // [1, 4, 9, 16, 25]
+
+// filter: selects elements based on condition
+const evens = numbers.filter(x => x % 2 === 0);
+console.log(evens); // [2, 4]
+
+// reduce: accumulates values
+const sum = numbers.reduce((acc, curr) => acc + curr, 0);
+console.log(sum); // 15
+
+// 4. Custom Higher Order Function Example
+function repeat(n, action) {
+    for (let i = 0; i < n; i++) {
+        action(i);
+    }
+}
+
+repeat(3, console.log); // Logs 0, 1, 2
+
+// 5. Returning Functions (Closures)
+function makeCounter() {
+    let count = 0;
+    return function() {
+        count++;
+        return count;
+    };
+}
+
+const counter = makeCounter();
+console.log(counter()); // 1
+console.log(counter()); // 2
+
+// 6. Practical Example: Function Composition
+function compose(f, g) {
+    return function(x) {
+        return f(g(x));
+    };
+}
+
+const add1 = x => x + 1;
+const times2 = x => x * 2;
+const add1ThenTimes2 = compose(times2, add1);
+console.log(add1ThenTimes2(5)); // (5 + 1) * 2 = 12
+
+
+const radius = [1, 2, 3, 4];
+const calculateArea = function (radius) {
+  const output = [];
+  for (let i = 0; i < radius.length; i++) {
+    output.push(Math.PI * radius[i] * radius[i]);
+  }
+  return output;
+};
+console.log(calculateArea(radius));
+
+const calculateCircumference = function (radius) {
+  const output = [];
+  for (let i = 0; i < radius.length; i++) {
+    output.push(2 * Math.PI * radius[i]);
+  }
+  return output;
+};
+console.log(calculateCircumference(radius));
+
+const radiusArr = [1, 2, 3, 4];
+
+// logic to calculate area
+const area = function (radius) {
+    return Math.PI * radius * radius;
+}
+
+// logic to calculate circumference
+const circumference = function (radius) {
+    return 2 * Math.PI * radius;
+}
+
+const calculate = function(radiusArr, operation) {
+    const output = [];
+    for (let i = 0; i < radiusArr.length; i++) {
+        output.push(operation(radiusArr[i]));
+    }
+    return output;
+}
+console.log(calculate(radiusArr, area));
+console.log(calculate(radiusArr, circumference));
+// Over here calculate is HOF
+// Over here we have extracted logic into separate functions. This is the beauty of functional programming.
+// We can also use built-in higher order functions like map to achieve the same result
+const areas = radiusArr.map(area);
+console.log(areas);
+const circumferences = radiusArr.map(circumference);
+console.log(circumferences);    
+
+
+

HigherOrderFunction/map.js

@@ -0,0 +1,73 @@
+
+const arr = [1, 2, 3, 4, 5];
+
+function double(x){
+    return x * 2;
+}
+
+function triple(x){
+    return x * 3;
+}
+
+const outputDouble = arr.map(double); 
+console.log(outputDouble); // [2, 4, 6, 8, 10]
+// alernate way to use map
+
+const outputDoubleAlt = arr.map(function(x) { // Using a regular function 
+    return x * 2;
+});
+// This is equivalent to the previous example
+// It uses a regular function instead of an arrow function  
+
+console.log(outputDoubleAlt); // [2, 4, 6, 8, 10]
+
+const outputDoubleAltArrow = arr.map(x => x * 2);
+console.log(outputDoubleAltArrow); // [2, 4, 6, 8, 10]
+
+const outputTriple = arr.map(triple);
+console.log(outputTriple); // [3, 6, 9, 12, 15]
+
+function binary(x) {
+    return x.toString(2);
+}
+const binaryArr = arr.map(binary);
+
+// The above code can be rewritten as :
+const binaryArr1 = arr.map(function binary(x) {
+    return x.toString(2);
+});
+
+// OR -> Arrow function
+const binaryArr2 = arr.map((x) => x.toString(2));
+
+const users = [
+    { firstName: "Aditya", lastName: "Kumar", age: 23 },
+    { firstName: "Ashish", lastName: "Kumar", age: 29 },
+    { firstName: "Ankit", lastName: "Roy", age: 29 },
+    { firstName: "Pranav", lastName: "Mukherjee", age: 50 },
+];
+const fullNameArray = users.map(x => {
+    return x.firstName + " " + x.lastName;
+})
+console.log(fullNameArray);
+
+// Polifill for map
+Array.prototype.myMap = function(callback) {
+  let result = [];
+  for (let i = 0; i < this.length; i++) {
+    result.push(callback(this[i], i, this)); // Pass current element, index, and array to the callback
+  }
+  return result;
+};
+//  This is a custom implementation of the map function that mimics the behavior of Array.prototype.map
+// It iterates over the array, applies the callback function to each element, and returns a new array with the results.
+// The callback function can take three arguments: the current element, its index, and the array
+// This allows for more flexibility in how the callback is used, similar to the built-in map
+// This custom implementation can be used in the same way as the built-in map function, allowing
+// developers to use it in their code without relying on the built-in method.
+// This is useful for environments where the built-in map function is not available or for educational purposes
+// Usage:
+console.log(arr.myMap(x => x * 200)); // [2, 4, 6]
+
+
+