Functions in JavaScript

Functions

1. Function is an object.

2. Function is a block of instruction used to perform a specific task.

3. A function gets executed only when it is called.

4. The main advantage of a function is that we can achieve code reusability.

5. To call a function, we need its reference and ().

6. The name of the function is a variable that holds the reference of the function object.

7. Creating a function using the function keyword supports function hoisting.

8. Therefore, we can also call a function before its declaration.

9. When we try to log the function name, the entire function definition is printed.

10. The scope within a function block is known as local scope.

11. Any member with local scope cannot be used outside the function block.

12. A parameter of a function will have local scope.

13. Variables written inside a function, even using var, have local scope.

14. Inside a function, we can use the members of the global scope.

15. In JavaScript, this is a property of every function (every function will have the this keyword except arrow functions).

Parameter

1. The variables declared in the function definition are known as parameters.

2. Parameters have local scope (can be used only inside the function body).

3. Parameters are used to hold the values passed by the caller (or calling statement).

Arguments

1. The values passed in the method call statement are known as arguments.

2. Note: An argument can be a literal, variable, or an expression that gives a result.

Return Keyword

1. It is a keyword used as a control transfer statement in a function.

2. Return will stop the execution of the function and transfer control along with data to the caller.

Ways to Create Functions

1. Function Declaration Statement: Create using function keyword

Syntax:

function func_variable(parameters) {    
  //statements
}
func_variable()

2.
Example: Create a function greet which should print a message "Good Morning" when it is called.
```
function greet() {
  console.log("Good Morning");
}
greet();
```

Function can be hoisted.

// Here, we are accessing the function before its declaration statement.
greet();
function greet() {
  console.log("Good Morning");
}

// Output: Good Morning

4.
Function does not belong to the Temporal Dead Zone.

Functional Programming

1. Functional Programming is a programming technique where we pass a function along with a value to another function.

2. In this approach, we generate Generic Functions. Here, the function's task is not predefined. It performs multiple tasks, not just a single task.

3. The function that accepts another function as a parameter or returns a function is known as a Higher Order Function.

4. The function that is passed to another function or the function that is returned by another function is known as a Callback Function.

Types of Functions

1. Function as Expression / Expression Function

1.
A function that is passed to a variable as a value is called a First-Class Function.
2.
The function cannot be hoisted because its object is created in the execution phase.
3.
The function does not belong to the Temporal Dead Zone.

2. Immediate Invoke Function (IIF)

1.
When a function is called as soon as its object is created, it is known as an Immediate Invoke Function.
2.
We have to write the function inside parentheses to group it (using the Group Operator → (function code)).
3.
The function is not visible (available) outside its scope.
4.
After grouping it, we have to use parentheses to call this function.
5.
An Immediate Invoke Function executes only once.

3. Arrow Function

1.
The main purpose of an arrow function is to reduce the function syntax.
2.
Arrow Functions were introduced in ES6.
3.
If we have only one parameter, it is not necessary to use parentheses for the parameter.
4.
If the function has a single statement, then the block (curly braces) is optional.
5.
It does not have its own this property.
6.
Implicit Return: If there is only one statement and no block is created, the JS Engine will return that statement automatically.
7.
Explicit Return: If a block is created and the function is not returning any value, the JS Engine will return undefined. To return a value explicitly from the block, we have to use the return keyword.

4. Higher Order Function

1.
The function that accepts another function as a parameter or returns a function is known as a Higher Order Function.

5. Callback Function

1.
The function that is passed to another function or the function that is returned by another function is known as a Callback Function.

Nested Function

Example:

function outer() {
  function inner() {
  }
}

2.
The outer function is known as the parent, and the inner function is known as the child.
3.
The inner function is local to the outer function; it cannot be accessed from outside.
4.
To use the inner function outside, the outer function must return the reference of the inner function.
```
function outer() {
  function inner() {
  }
  return inner;
}
```
We can now call the inner function from outside as follows:

1st Way:
```
let fun = outer();
fun();   // -----> inner() is called
```
2nd Way:
```
outer()();   // -----> inner() is called
```