How to Init Functions in JavaScript

Functions are one of the most fundamental elements of JavaScript. The JavaScript function is very similar to that of a procedure.

A set of instructions/statements performs a task or calculates a value. For a procedure to qualify as a function, it must require input and return an output when tested.

To use a function, you must define it within the scope you want to call it.

In today’s article, we will learn about init functions in JavaScript.

the Init Functions in JavaScript

When functions are used only once, an Immediately Invoked Function Expression (IIFE) is common.

(function() {
/* Set of instructions */
})();
(() => {
     /* Set of instructions */
 })();

IIFEs are function expressions called as soon as the function is declared. Function declarations that do not begin with function are function expressions.

A normal function definition is also known as a function statement or function declaration. This function declaration consists of the keyword function followed by:

1. The unique name of the function.
2. All the parameters required for the function are enclosed in parentheses and separated by commas.
3. The JavaScript declarations define the function. It is enclosed in square brackets, {...}.

One of the advantages of creating a named function expression is that if we encounter an error, the stack trace will include the function name, making it easier to find the source of the error.

IIFEs is a design pattern, also known as a self-executing anonymous function, with two main parts.

1. The first is the lexically delimited anonymous function, which is contained in the grouping operator (). This prevents access to variables within the IIFE language and pollutes the world scope.
2. The second part creates the function that is immediately invoked function expression (), which allows the JavaScript engine to interpret the function directly.

const additionFunction = function() {
  console.log(2 + 3)
};
additionFunction();

(function() {
console.log(2 + 3)
})();

Because our application might contain many functions and global variables from different source files, it is important limiting the number of global variables.

Let’s take an example of the above code; we have declared two functions. Both the functions perform similar task and prints the result 5.

If we have startup code that we don’t need to reuse, we can use the IIFE pattern.

The code will not be reused. In this case, using IIFE is better than using a function declaration or expression.

When you run the above code in any browser, it will print something like this.

Output:

"5"
"5"