The main difference between “==” and “===” operator is that formerly compares variable by making type correction e.g. if you compare a number with a string with numeric literal, == allows that, but === doesn’t allow that, because it not only checks the value but also type of two variable, if two variables are not of the same type “===” return false, while “==” return true.

Infosys

Frontend Developer

Software Engineer

Difference between “ == “ and “ === “ operators.

The Temporal Dead Zone is a behavior in JavaScript that occurs when declaring a variable with the let and const keywords, but not with var. In ECMAScript 6, accessing a let or const variable before its declaration (within its scope) causes a ReferenceError. The time span when that happens, between the creation of a variable’s binding and its declaration, is called the temporal dead zone.

Example: 

```
function test() {
  console.log(num1); // undefined
  console.log(num2); // ReferenceError
  var num1 = 1;
  let numr2 = 2;
}
```

What is the Temporal Dead Zone?

Hoisting is a JavaScript mechanism where variables, function declarations and classes are moved to the top of their scope before code execution. Remember that JavaScript only hoists declarations, not initialisation. Let's take a simple example of variable hoisting,

```
console.log(message); //output : undefined
var message = "The variable Has been hoisted";
```

The above code looks like as below to the interpreter,

```
var message;
console.log(message);
message = "The variable Has been hoisted";
```

In the same fashion, function declarations are hoisted too


```
message("Good morning"); //Good morning

function message(name) {
  console.log(name);
}
```

This hoisting makes functions to be safely used in code before they are declared.



What is Hoisting?

**Call**: The call() method invokes a function with a given context i.e this value and arguments provided one by one

```
let user1 = {name: "BigODev", city: "London"}

function welcome(msg1, msg2) {
  console.log(msg1 + this.name + "from" + this.city + msg2);
}

welcome.call(user1, "Hello," "How are you?"); // Hello BigODev from London How are you?

```

**Apply**: Invokes the function with a given context i.e this value and allows you to pass in arguments as an array

```
let user = {name: "BigODev", city: "London"}

function welcome(msg1, msg2) {
  console.log(msg1 + this.name + "from" + this.city + msg2);
}

welcome.apply(user, ["Hello," "How are you?"]); // Hello BigODev from London How are you?
```

**Bind**: returns a new function, allowing you to pass any number of arguments

```
let user1 = {name: "BigODev", city: "London"}

function welcome(msg1, msg2) {
  console.log(msg1 + this.name + "from" + this.city + msg2);
}

let welcomeUser = welcome.bind(user1); 
welcomeUser("Hello", "How are you?")
```

What is the difference between Call, Apply and Bind?

LocalStorage is the same as SessionStorage but it persists the data even when the browser is closed and reopened(i.e it has no expiration time) whereas in sessionStorage data gets cleared when the page session ends.

What is the main difference between localStorage and sessionStorage?

A Service worker is basically a script (JavaScript file) that runs in the background, separate from a web page and provides features that don't need a web page or user interaction. Some of the major features of service workers are Rich offline experiences(offline first web application development), periodic background syncs, push notifications, intercept and handle network requests and programmatically managing a cache of responses.

Top Javascript Interview Questions

1. Difference between “ == “ and “ === “ operators.

2. What is the Temporal Dead Zone?

3. What is Hoisting?

4. What is the difference between Call, Apply and Bind?

5. What is the main difference between localStorage and sessionStorage?

6. What is a service worker?