Author: admin

  • JavaScript – Short-Circuiting

    In JavaScript, short-circuiting is a feature that checks conditions and stops as soon as it knows the answer. It doesn’t look for the rest of the expression, and that prevent unnecessary evaluations.

    Short-Circuiting for && operator

    Short circuit evaluation with &&(AND) logical operator means if the first expression evaluates to false then whole expression will be false and the rest of the expressions will not be evaluated.

    Code-snippet

    Below is an example snippet of short-circuiting with the && operator.

    let x =0&&"hello";// x will be 0, as 0 is falsy and short-circuitslet y =true&&"world";// y will be "world" because the first value is truthylet z ="hello"&&"world";// z will be "world" because both values are truthy
    console.log(x);// 0
    console.log(y);// world
    console.log(z);// world

    Output

    Following is the output of the above code

    0
    world
    world
    

    Short-Circuiting for || operator

    Short circuit evaluation with ||(OR) logical operator means if the first expression evaluates to true then whole expression will be true and the rest of the expressions will not be evaluated.

    Code-snippet

    Below is an example snippet of short-circuiting with the || operator.

    let x =0||"hello";// x will be "hello" because 0 is falsylet y =true||"world";// y will be true because the first value is truthylet z ="hello"||"world";// z will be "hello" because the first value is truthy
    console.log(x);// hello
    console.log(y);// true
    console.log(z);// hello

    Output

    Following is the output of the above code

    hello
    true
    hello
    

    Short-Circuiting Assignment

    Short-circuiting can be used in assignment operations as well. Means, if you have to assign something based on a condition, you can use short-circuiting.

    Code-snippet

    Below is an example snippet of short-circuiting in assignment operations.

    let x =0;let y =10;let z = x || y;// z will be 10 because x is falsy
    console.log(z);// 10

    In above example, z will be assigned the value of y because x is falsy.

    Output

    Following is the output of the above code

    10
    

    Short-Circuiting in Function Calls

    Short-circuiting can be used in function calls as well. Means, if you have to call a function based on a condition, you can use short-circuiting.

    Code-snippet

    Below is an example snippet of short-circuiting in function calls.

    functiongreet(name){return name ||"Guest";}let x =greet("John");// x will be "John" because name is truthylet y =greet("");// y will be "Guest" because name is falsy
    console.log(x);// John
    console.log(y);// Guest

    In above example, if name is truthy, it will return the name, otherwise it will return “Guest”.

    Output

    Following is the output of the above code

    John
    Guest
  • JavaScript – Rest Operator

    There are times when we want to pass any number of arguments to a function or want to get specific elements separately from an array or object. In such cases, we can use the rest operator.

    What is Rest Operator?

    The rest operator () allows us to call a function with any number of arguments and then access those excess arguments as an array. The rest operator also allows us in destructuring array or objects.

    Rest Operator with Function Parameters

    When you define a function, you can use rest operator to get all remaining arguments inside an array. This process helps us to pass any number of arguments without knowing how many they are.

    Code-Snippet

    Below is an example snippet of using rest operator in function parameters. We will sum all the numbers passed to the function.

    functionsum(...args){let total =0;for(let i of args){
         total += i;}return total;}
    
    console.log(sum(1,2,3,4,5));// 15
    console.log(sum(1,2,3));// 6

    Output

    15
    6
    

    Rest Operator with Array Destructuring

    If you have given an array, and if you want specific element separately and rest of the elements in a separate array, you can use rest operator.Rest operator also help us to destructure an array.

    Code-Snippet

    Below is an example snippet of using rest operator with array destructuring for getting first and second element separately and rest of the elements in a separate array.

    let arr =[1,2,3,4,5];let[first, second,...rest]= arr;
    
    console.log(first);// 1
    console.log(second);// 2
    console.log(rest);// [3, 4, 5]

    Output

    1
    2
    [3, 4, 5]
    

    Rest Operator with Object Destructuring

    Now, if you want specific properties separately and rest of the properties in a separate object, you can use rest operator for achieving that. Rest operator also help us to destructure an object.

    Code-Snippet

    Below is an example snippet of using rest operator with object destructuring for having first and second property separately and rest of the properties in a separate object.

    let obj ={ name:"Aish", age:21, city:"Hyderabad", country:"India"};let{ name, age,...rest }= obj;
    
    console.log(name);//  Aish
    console.log(age);// 21
    console.log(rest);// { city: "Hyderabad", country: "India" }

    Output

    Aish
    21
    { city: "Hyderabad", country: "India" }
  • JavaScript – Reduce Method

    What is Reduce Method?

    In JavaScript, Reduce method is used to manipulate array. This method executes a reducer function on each element of the array (from left to right) and returns a ‘single value’ as a result.

    It accepts an optional parameter named ‘initialValue’. If we do not pass this parameter to the method, it will consider the arr[0] value as the initial value. Additionally, it will execute the callback function on the passed initialValue parameter.

    This method does not execute the reducer function for empty array elements. In addition to that, it does not modify the original array.

    Note : If the current array is empty or doesn’t contain any initialValue, this method will throw a ‘TypeError’ exception.

    Syntax

    Following is the syntax of JavaScript Array.reduce() method

    reduce(callbackFn(accumulator, currentValue, currentIndex, array), initialValue)

    Parameters

    The reduce() function has two parameters which are callbackfn() and initialValue. They are described below in detail.

    • initialValue (optional): The value to which the accumulator parameter is initialized when the first time the callback function is called.
    • callbackFn: This is the function that executes on each element in the array.

    The callbackFn() function in turn takes four arguments They are –

    • accumulator: This is the current element being processed in the array. If the initialValue is specified, its value will be arr[0], if not its value will be arr[1].
    • currentValue: It refers to the current element.
    • currentIndex (optional): This is the index of the current element being processed in the array.
    • array (optional): This is the array on which the reduce() method is called.

    Return Value

    This method returns the single value that is the result after reducing the array.

    Example

    In the following example, we are using the JavaScript Array.reduce() method to sum all the elements present in the provided array.

    <html><body><script>const number =[10,20,30,40,50];const sum = number.reduce((accumulator, currentValue)=> accumulator + currentValue,0);
    document.write(sum);</script></body></html>

    The accumulator starts at 0, and for each element in the array, it adds the current element to the accumulator. The final result of the accumulator (150) is the sum of all the elements.

    Output

    Following is the output of the above code

    150
    

    Example

    If the current array does not contain any element(no initial value available), the reduce() method will throw a “TypeError” exception

    <html><body><script>const numbers =[];try{
          numbers.reduce((accumulator, currentValue)=> accumulator * currentValue);}catch(error){
          document.write(error);}</script></body></html>

    Output

    Following is the output of the above code

    TypeError: Reduce of empty array with no initial value
    

    Reduce method on TypedArray

    We can use reduce method on TypedArray as well. Everything is similar to normal array, means we can process and combine elements in same way as we do with arrays.

    Syntax

    Following is the syntax of JavaScript TypedArray reduce() method

    TypedArray.reduce(callbackFn(accumulator, currentValue, currentIndex, array), initialValue)

    Example

    The product of all elements within a typed array.

    In the following example, we are using the JavaScript TypedArray reduce() method to execute the user-provided function named multi() on each element of this typed array [1, 2, 3, 4, 5]. The multi() function multiplies all the elements within the current typed array.

    <html><head>
    JavaScript TypedArray reduce() Method
    </head><body><script>//functionfunctionmulti(accumulator, currentValue){return accumulator * currentValue;}const T_array =newUint16Array([1,2,3,4,5]);
    document.write("Typed array: ", T_array);//Using the reduce() method
    document.write("<br>The product of typed array elements: ", T_array.reduce(multi));</script></body></html>

    Output

    Following is the output of the above code

    Typed array: 1,2,3,4,5
    The product of typed array elements: 120
    

    Example

    If the current typed array does not contain any element(no initial value available), the reduce() method will throw a “TypeError” exception.

    In the given example below, we use the JavaScript TypedArray reduce() method to execute the user-provided reducer callback function named “ArrowFunction” on each element of this empty typed array ([]).

    <html><head><title>JavaScript TypedArray reduce() Method</title></head><body><script>const T2_array =newUint16Array([]);//empty typed array
    document.write("Length of the typed array: ", T2_array.length);//using the reduce methodtry{
       T2_array.reduce((a, b)=> a + b);}catch(error){
        document.write("<br>", error);}</script></body></html>

    Output

    Following is the output of the above code

    Length of the typed array: 0
    TypeError: Reduce of empty array with no initial value
    

    Reduce method on Map

    We can use reduce method on Map as well. Everything is similar to normal array, means we can process and combine elements in same way as we do with arrays.

    Syntax

    Following is the syntax of JavaScript Map reduce() method

    Map.reduce(callbackFn(accumulator, currentValue, currentIndex, array), initialValue)

    Example

    The sum of all elements within a Map.

    In the following example, we are using the JavaScript Map reduce() method to execute the user-provided function named add() on each element of this map. The add() function adds all the elements within the current map.

    <html><head><title>JavaScript Map reduce() Method</title></head><body><script>//functionfunctionadd(accumulator, currentValue){return accumulator + currentValue;}const map =newMap([[1,2],[3,4],[5,6]]);
    document.write("Map: ", map);//using the reduce() method
    document.write("<br>The sum of map elements: ",[...map.values()].reduce(add));</script></body></html>

    Output

    Following is the output of the above code

    Map: 1 => 2,3 => 4,5 => 6
    The sum of map elements: 12
  • JavaScript – Reactive Programming

    Reactive Programming is basically a way to write code that makes it easier to deal with things happens over timelike data coming from a network, users clicking on stuff, or updates popping up in a database. In reactive programming, we look at data as a stream of events. So instead of just waiting a lot for data to be ready, were kind of subscribe to these events and responding as soon as they happen.

    Working with async (asynchronous) data gets a lot simpler with reactive programming. Async data can usually be tough because we dont know exactly when it will show up. But here in reactive programming, everything acts like a stream; we just listen for the data and handle it as soon as its ready.

    Secondly, the reactive programming can actually make our code faster, because we get notified exact the moment new data comes in. We dont have to keep checking for it; it just shows up when its ready, and this makes a lot easier for us.

    Lastly, this makes our code more understandable and manageable. because were handling data as a flow of events, its clear how the different pieces of code connect with each other. The code becomes more declarative, we just say what should happen, and it takes care of reacting to events in the right order. So its not only efficient but also keeps things cleaner and easier to work.

    Reactive Programming in JavaScript

    There are several libraries and frameworks that help us write reactive code in JavaScript. Some of the most popular ones are:

    • RxJS: RxJS is a JavaScript library that gives tools for reactive programming. It is a popular framework, It is also used a lot with frameworks like Angular, and you may also have seen used with React. RxJS lets us handle data as a stream of events, that makes it much simple to deal with async stufflike user actions, API calls, or real-time updates.
    • React: React is a JavaScript library mostly for building user interfaces. The great part is if data changes behind the scenes, React just updates the UI for us. React uses a virtual DOM which is a simple version of the actual webpage so it only updates the specific parts of the page, instead of updating whole webpage each time. This makes things faster as less time needed to update some of components.
    • Vue.js: Vue.js is also a JavaScript framework for building user interfaces, and its designed to grow along with your project. It has a reactive data model, meaning if the data changes, the UI automatically changes. Vue has handy tools like computed properties (which handle data that depends on other data) and watchers (which track changes and let us react to them right away). This makes Vue pretty straightforward and really useful for building interactive features.
  • JavaScript – Prototype

    Prototype is like a template in JavaScript. These template help object to share the properties and methods. Instead of duplicating code everywhere, we can define method or property once and then can easily share with other instances of an object.

    Types of Prototype in JavaScript

    In JavaScript, there are more than one type of prototype that are used to share the properties and methods among the objects. The main types of prototype in JavaScript are:

    • Object Prototype
    • Constructor Function Prototype
    • Function Prototype
    • Built-in Prototype

    Object Prototype

    The object prototype is foundational template to all objects in JavaScript. This template is available in every object we create by default. It is like built-in sheet of tool that every object can use.

    Code Snippet

    Following is an example snippet of using object prototype.

    let obj ={
       name:"John",
       age:21};
    console.log(obj);
    console.log(obj.toString());// [object Object]

    Output

    Following is the output of above code snippet −

    { name: 'Ansh', age: 24 }
    

    In above example, we have created an object named obj with properties name and age. We also have used toString() method which is available by default in object prototype.

    Constructor Function Prototype

    A construction function is type of function that is used for creating new objects. When we need to create multiple objects having same properties and behaviours, we can use constructor function. Constructor function prototype is used to share the properties and methods among the objects created using constructor function.

    Code Snippet

    Below is an example snippet of using constructor function prototype.

    functionPerson(name, age){this.name = name;this.age = age;}Person.prototype.greet=function(){return"Hello, "+this.name;}let person1 =newPerson("John",21);let person2 =newPerson("Ansh",24);

    Output

    Following is the output of above code snippet.

    Hello, John
    Hello, Ansh
    

    In above example, we have created a constructor function named Person. We also have added a method greet to the prototype of Person. We have created two objects person1 and person2 using Person constructor function and then called greet method on both objects.

    Function Prototype

    Function prototype is a template that is available to all functions in JavaScript. This template is used to share the properties and methods among the functions.

    Code Snippet

    Below is an example snippet of using function prototype.

    functiongreet(){return"Hello, World!";}
    console.log(greet.toString());// function greet() { return "Hello, World!"; }

    Output

    Following is the output of above code snippet.

    function greet() { return "Hello, World!"; }
    

    In above example, we have created a function named greet. We also have used toString() method which is available by default in function prototype.

    Built-in Prototype

    There are many built-in objects in JavaScript like Array, String, Number, etc. These built-in objects have their own prototype. We can use these prototypes to share the properties and methods among the objects of these built-in objects.

    Code Snippet

    Below is an example snippet of using built-in prototype.

    let arr =[1,2,3,4,5];
    
    console.log(arr);
    console.log(arr.toString());// 1,2,3,4,5
    console.log(arr.join("-"));// 1-2-3-4-5
    console.log(arr.reverse());// [ 5, 4, 3, 2, 1 ]

    Output

    [ 1, 2, 3, 4, 5 ]
    1,2,3,4,5
    1-2-3-4-5
    [ 5, 4, 3, 2, 1 ]
    

    In above example, we have created an array named arr. We also have used toString()join(), and reverse() methods which are available by default in array prototype.

  • JavaScript – Parameters vs Arguments

    Parameters and arguments are terms that are used for the function. Both are generally confused with each other. But they are different from each other in JavaScript. In this tutorial, we will learn about the difference between parameters and arguments in JavaScript.

    Parameters

    Parameters are variable names that are used in the function definition. They are used to hold the values of the arguments that are passed to the function.

    Arguments

    Arguments are used in the function call. These are the values that are passed to the function when it is called. They are the actual values that are passed to the function when it is called.

    We can pass any number of arguments to the function. But the number of arguments should match the number of parameters in the function definition. If the number of arguments is less than the number of parameters, the remaining parameters will be undefined. If the number of arguments is more than the number of parameters, the extra arguments will be ignored.

    Parameters vs Arguments

    Following are the notable Differences Between Parameters and Arguments −

    ParametersArguments
    Parameters are the variable names that are used in the function definition.Arguments are the real values that we need to pass to the function when it is called.
    Parameters are used to hold the values of the arguments that are passed to the function.Arguments are the values that are passed to the function when it is called.
    Parameters are used in the function definition.Arguments are used in the function call.

    Example

    Lets see an example −

    <html><body><script>functionadd(a, b){return a + b;}
    document.write(add(10,20));</script></body>

    Output

    30
    

    Explanation

    In the above example, there is a function called add() that adds up the two numbers. In the function definition, there are two parameters a and b. When the function is called, the values 10 and 20 are passed as arguments to the function. These values are stored in the parameters a and b. The function returns the sum of these two values.

  • JavaScript – Functional Programming

    There are mainly two programming paradigms: The imperative programming paradigm and the declarative programming paradigm. Functional programming is a subtype of the declarative paradigm. The paradigm word refers to the approach to solving a particular problem.

    Functional programming has been in use for the last decades but came in the trend after 2015 when the last main revised version of JavaScript was released. There are many benefits to using functional programming, which we will discuss in this tutorial.

    Characteristics of Functional Programming

    Functional programming works as mathematical function works. It allows developers to develop software based on function evaluation. It means programmers can break the code into small parts, which we can call the function, making it easy to evaluate and test code. The following concepts of functional programming are covered in this tutorial

    • Pure Functions
    • Code Readability

    Pure Functions in JavaScript

    In JavaScript, we can write the pure function. In simple terms, a pure function takes the values as a parameter, performs some operations on that, and returns the output.

    The pure function never shares any variable with other function or use a global variable.

    The followings are the properties of a Pure function

    • A pure function always returns the same output for a given input.
    • A pure function does not depend on any external state or variables that are not passed to them as arguments.
    • A pure function does not produce any side effects, such as modifying global variables or changing the state of external objects.

    Now, let us see and understand the pure function with an example.

    Example

    In the example below, we have created the pure_func() named which takes the value as a parameter and multiplies it with 2. After that, it prints the value. Users can see that pure_func() is not sharing any variable globally with another function.

    Also, we can use the global_var directly without passing it as a parameter of a pure function. Still, we have passed it as a parameter as a pure function never shares any variable declared outside the function’s scope.

    <html><body><h2>Pure Function Example</h2><div id="result"></div><script>let result = document.getElementById('result');let global_var =10;functionpure_func(value){return value *2;}
    result.innerHTML =pure_func(5);</script></body></html>

    Immutability in JavaScript

    Immutability is another important concept of functional programming. In simple terms, immutability means that we cannot change the value of the variable once it is declared. In JavaScript, we can achieve immutability by using the const keyword. Lets see an example of immutability in JavaScript.

    Example

    In the example below, we have declared the variable using the const keyword. We have tried to change the value of the variable, which will throw an error as we cannot change the value of the variable declared using the const keyword.

    <html><body><h2>Immutability Example</h2><div id="result"></div><script>let result = document.getElementById('result');const value =10;
    value =20;
    result.innerHTML = value;</script></body></html>

    Ouptut

    Following is the output of the above code

    TypeError: Assignment to constant variable.
    

    When we run the above code, it will throw an error as we cannot change the value of the variable declared using the const keyword.

    Code Readability

    As we write all logic with functions in functional programming, it makes our code more readable. For example, in other programming languages we use for or while loops to iterate through the arrays. But functional programming allows us to use the for-of loop, which makes code more readable and tells other developers that we wanted to iterate through the array and perform some operation on every array element.

    Lets look at another example. Suppose we want to filter some values from the array. In other programming approaches, we write a manual function to filter values, but in the functional programming approach, we can use the filter() method, demonstrating that we want to filter values from the array based on the particular logic.

    Higher Order Functions

    The higher-order function allows us to pass the function as an argument of another function. For example, we can pass the callback function as an argument of the reduce() method of the array. In the callback function, we can write logic to reduce an array into a single element.

    Lets see an example of the higher-order function.

    Example

    In this example, we have used the reduce() method to reduce the array into a single element and passed the callback function as an argument. It represents the higher-order function as we have passed the function as an argument.

    <html><body><h2>Higher Order Function Example</h2><div id="result"></div><script>let result = document.getElementById('result');let arr =[1,2,3,4,5];let sum = arr.reduce((acc, val)=> acc + val);
    result.innerHTML = sum;</script></body></html>

    We have learned about the functional programming approach and how it is beneficial and different from the programming paradigm. We have learned that it provides a way to write maintainable and readable code with fewer bugs.

  • JavaScript – Form Handling

    We can handle forms in different ways like validating, submitting, altering, updating form data, etc. using JavaScript.

    Form Validation

    Form validation normally occurs at the server, after the client had entered all the necessary data and then pressed the Submit button.

    If the data entered by a client was incorrect or was simply missing, the server would have to send all the data back to the client and request that the form be resubmitted with correct information. This was really a lengthy process which used to put a lot of burden on the server.

    JavaScript provides a way to validate form’s data on the client’s computer before sending it to the web server. Form validation generally performs two functions.

    • Basic Validation First of all, the form must be checked to make sure all the mandatory fields are filled in. It would require just a loop through each field in the form and check for data.
    • Data Format Validation Secondly, the data that is entered must be checked for correct form and value. Your code must include appropriate checks to ensure that the data entered is the data you are expecting.

    Code snippet

    functionvalidateForm(){var x = document.forms["myForm"]["fname"].value;if(x ==""){alert("Name must be filled out");returnfalse;}}validateForm();

    In the above code, we have declared a function validateForm that checks if our form inputs are valid and input are properly fille, If not it will alert us to fill the missing data.

    Following is the output of the above code:

    Name must be filled out
    

    Form Submit

    After validating the form, we can submit the form data to the server. We can use methods like submit() and reset() to submit and reset the form data.

    Code snippet

    <form id="myForm" action="">
       First name:<input type="text" name="fname"><br>
       Last name:<input type="text" name="lname"><br><br><input type="button" value="Submit" onclick="myFunction()"></form><script>
    document.getElementById("myForm").submit();
    document.getElementById("myForm").reset();</script>

    In the above code, we have used the submit() method to submit the form data and reset() method to reset the form data.

    Conclusion

    We can handle forms easily in JavaScript. Validation becomes a lot more easier and faster with JavaScript. We can also submit and reset the form data using JavaScript.

  • JavaScript – Empty String Check

    String is a data type, which we can use to save the data present in text format. It is a sequence of characters inside the double or single quotes.

    Sometimes we need to check whether the string is empty or not. In JavaScript, we can check the empty string using the following methods.

    Using the length property

    It’s really simple and most common way to check the empty string. All we have to do is check the length of the string using the length property of the string. If the length of the string is 0, then it is an empty string. If length is 1 or more than 1 then string is not empty.

    Syntax

    Below is the syntax given to check the empty string using the length property.

    if(string_name.length ===0){// string is empty}

    Example

    Below is the example code given, that shows how to use the length property to check the empty string.

    <html><body><script>var str ='';if(str.length ===0){
       document.write('String is empty');}</script></body></html>

    Following is the output of the above program −

    String is empty
    

    Using the trim() method

    The string.trim() method allows us to remove the space from the start of the string. After moving the space, we can check that if the strings length is zero, the string can be either empty, null, or undefined.

    Syntax

    Below is the syntax given to check the empty string using the trim() method.

    if(string_name.trim()===''){// string is empty}

    Example

    Below is the example code given, that shows how to use the trim() method to check the empty string.

    <html><body><script>var str =' ';if(str.trim()===''){
       document.write('String is empty');}</script></body></html>

    Following is the output of the above program −

    String is empty
    

    So, we have seen how to check the empty string in JavaScript using the length property and trim() method.

  • JavaScript – Higher Order Function

    A higher order function accepts other functions as parameters and returns a function. To know about Higher-order functions, we should learn about call back functions.

    A call back function is a function that is passed to another function as an argument. With the help of call back functions, one function can call another function and the call back function runs only after other function has finished. Some of the higher-order functions are map, reduce and filter.

    Let us take an example and implement it without using any higher order functions.

    Example

    In the following code, we have a list of numbers and we want to increment each element by 10, to achieve this without using higher order functions, we need to loop through the array using for loop and increment each value by 10 and push the incremented values to a new array. Finally, print the incremented array using console.log().

    const numbers =[1,2,3,4,5];
    incrementedNums=[]for(i =0; i < numbers.length; i++){
       added = i +10
       incrementedNums.push(added)}
    console.log(incrementedNums)

    Output

    [ 11, 12, 13, 14, 15 ]
    

    And this is how a map function works. It iterates over an array and executes a provided function once for each array element and return the output as an array. Map() function does not change the original array, also it does not perform the operation on an empty array.

    Below JavaScript functions are some inbuilt Higher Order Functions

    • map()
    • filter()
    • reduce()
    • forEach()

    Advantages of Higher Order Functions

    Following are the advantages of Higher Order Functions −

    • Code Reusability
    • Less Code
    • Easy to Understand
    • Easy to Maintain

    Usage of Higer Order Function

    Let us take the same example and implement it using higher order functions.

    Using map() function

    map() function iterates through an array and appllies a callback functionfor every element in the array. Let us consider another example and understand. In the following example, map function iterates through the given array of numbers and passes them into sqrt function, resulting an output of root values.

    numbers=[4,9,16,25,36]
    root= numbers.map(Math.sqrt)
    console.log(root)

    Output

    [2, 3, 4, 5, 6]
    

    Using filter() function

    The filter() method shallow copies of the array and filters down the value which passes the condition implemented by the provided callback function. It is an iterative method, which calls the callback function given as an argument for each element in the array and return an output array with the elements which returned truthy value by the callback function.

    Example

    In the following example, we have a list of numbers and we want to filter out the even numbers from the list. To achieve this, we need to use filter() function and pass a callback function which returns true if the number is even.

    numbers=[10,11,12,14,15]
    
    even=numbers.filter(iseven)functioniseven(n){return(n%2===0)}
    console.log(even)

    Output

    [ 10, 12, 14 ]
    

    Using reduce() function

    Similar to map and foreachreduce method also executes a callback function (reducer function) on every element of the array, resulting a single output. In simple terms, the reduce method reduces the array to a single value. The Parameter of the reducer function is a callback function, which further has two arguments, accumulator and current value. Where current value is the current iterated value of the array. accumulator accumulates the callback function’s output. The final return value is stored in the accumulator.

    Example

    In the following example, we have a list of numbers and we want to find the sum of all the numbers in the list. To achieve this, we need to use reduce() function and pass a callback function which returns the sum of two numbers.

    numbers=[10,11,12,13]
    
    total =numbers.reduce(function(acc,el){return acc+el
    },0)
        
    console.log(total)

    Output

    46
    

    Using forEach() function

    The forEach method is similar to a map function, where it executes the callback function for each element in the array. The only difference between forEach() and map() is that, map function returns an array output, where as forEach returs undefined, it just iterates through the array.

    Example

    Below code shows the working of forEach method

    const numbers =[10,20,30,40];
    
    sum=0
    numbers.forEach(add)functionadd(n){
       sum=sum+n
    }
    console.log(sum)

    Output

    100
    

    Conclusion

    Higher Order Functions operate on other functions, either by taking them as arguments or by returning them. JavaScript being a functional programming language, supports Higher Order Functions. Higher Order Functions are used to make the code more readable and maintainable. They help in reducing the code and make it more concise. JavaScript provides inbuilt Higher Order Functions like map(), filter(), reduce() and forEach().