Content of this blog:

Function Declaration:

The first way to Declare a function in JavaScript:

funtion add(num1,num2){
return num1+num2;

let result = add(1,2);

console.log("sum", result);

2nd way to Declare a function in JavaScript using Anonymous Function:

function without a name.

Functions that either accept or return other functions are called Higher Order Functions.

greet is a Higher Order function.

3rd way by Function Expression:

Example of Function passes as Parameter:

// function passed as a paramter
function welcome(){
    console.log("Hello World");

}
function goodbye(){
    console.log("See you later");

}

function greet(choice){
    choice();
}

greet(welcome);   
greet(goodbye);

/*
Output: 
        Hello World
        See you later
*/

Function Parameters:

Default Parameters Helps to set a value to Parameters.
You can have more than one default parameters in JavaScript.

function multiply(num1,num2=1){
return num1*num2;
}

console.log(multiply(3,2));  // 6
console.log(multiply(4));   // 4

console.log(multiply(3,undefined);  // 3

Function parameters can be also Destructured.
It will be useful when we will work on Objects and arrays as function parameters.
Example:

// Destructured Parameters - Array
function showDetails([arg1,arg2]){
console.log(arg1);
console.log(arg2);
}

showDetails([ "Rahul", "Razz", "Rohan" ]); 
/** Output:
      Rahul
      Razz
*/

Example 2:

// Destructured Parameters - Object
function showDetailsOBj({ name, country }){
  console.log(name);
  console.log(country)
}

showDetailsObj({name: "Rahul", age: 25, country: "India" })

/** Output:
      Rahul
      25
*/

Arrow Functions:

Arrow Function is a concise way of writing a function.
Arrow Functions are anonymous functions as they don’t have a name for them.

Let’s create an Arrow function:

function greet(choice){
    choice();
}

// greet(function(){ console.log('Hello World') });  

// another way of writing this: Arrow function
greet(()=>{console.log('Hello World')});

Different Ways to write arrow functions:

1. Arrow function with Multi parameter, multi-line code.

example:

let calculateTripCost = (ticketPrice,noOfPerson) =>{
    totalCost = ticketPrice * noOfPerson;
    return totalCost;
}

console.log("Total Cost: ", calculateTripCost(1200,4));
//  Total Cost: 4800

2. Arrow Function with No parameter, single line code.:

If the arrow function body contains only one line then no need to put curly braces for the function body.

example:

let trip = () => console.log('Lets go to trip');

trip();   // Lets go to trip

3. Arrow function with One parameter, single line code.

If an arrow function takes only one parameter then we need not to have even the small brackets surrounding them.

Example:

let trip = place => console.log('Lets go for trip ', + place);
trip('Paris'); // Lets go for trip Paris

let trip = _ => console.log('Lets go for trip ', + _ );
trip('Paris'); // Lets go for trip Paris

Variables Scopes:

Local Scope
Global Scope
Block Scope

Example:

The variable which is declared in the global scope can be accessed inside local access.

The variable which is declared in local scope can not be accessed outside the local access.

Always create a variable with let keyword, if you don’t use it it will act as a global variable.

example:

JavaScript first finds the variable in the same scope.

example:

You can see in the above example, the value of the global variable is printed.

As you can see the output first, find the variable in local scope if it is there then the value of that will be printed.

Block Scope Variable:

the variable which is declared inside a block that is accessible inside that block only. that’s why In the above example, the value of globalVar is printed from the global scope.

Now You can see the block scope variable is accessed.

Summary of Scopes:

A Variable that is declared in a block is called Block Scoped Variables. It is accessible inside that block only where it is declared.
A Variable that is declared inside a function is called Local Scoped Variable. It is accessible inside that function and block(means in Local Scope).
A Variable that is outside of block and local scope is called Global Scoped Variable. It is accessible from anywhere.