Advanced JavaScript Interview Questions

In ES6, Temporal Dead Zone is a behavior occurring in JavaScript while declaring a variable with the let and const keywords. The period between entering the scope and being declared is the one when these keywords cannot be accessed and enter the Temporal Dead Zone.

For example

console.log(foo); // undefined
var foo = 123;

console.log(foo); // Error
let foo = 123;

If you consider that the const and let are also in place, why can't they be accessible before they are declared? The answer is within the idea of the Temporal Dead Zone.

Variables declared with let and const are stored and placed in the Temporal Dead Zone. Therefore, they cannot be accessible before the declaration is executed during the step-by-step process of scripting.

Temporal Dead Zone is the duration that let and const declarations are not accessible. Declarations of the let as well as const declarations are not accessible.

Temporal Dead Zone is activated when code execution is entered into the block that includes let or const declarations. It continues until the lets or const declaration. It continues until the declaration is executed.

Interestingly enough, it is both. Primitive types like number, string, etc. are passed by value, but objects can be passed-by-value (when we consider a variable holding an object is a reference to the object) and also as a pass-by-reference (when we consider variable to the object is holding the object itself).

To ensure that an object is deep-frozen, you will have to create a recursive function for freezing each property of type object: Without deep freeze.

In JavaScript, this operator always refers to the object, which is invoking the function being executed. So, if the function is currently being used as an event handler, this operator will refer to the node which fired the event.

Here's the code to calculate the Fibonacci series in JS code:

A JavaScript default behavior that moves the declaration of variables and functions at the top of the current scope is called JavaScript hosting. You can use hosting for declaration, not for initialization.

OR

Hoisting in JavaScript is a method where a function or variable may be utilized prior to declaration.

1. Variable hoisting

console.log(x); // undefined
var x = 1;

2. Function hoisting

let x = 20, y = 10;
let result = add(x,y);
console.log(result);
function add(a, b) {
     return a + b;
}

1) Using the arrow function, you can get the same results as normal functions by writing a few lines of code as shown in the example below.

//Example of Regular function:
var add = function(c, d) { return c + d;};

// Example of Arrow function
let add = (c, d) => { return c + d}; //or
let add = (c, d) => c + d;

2) In normal functions, argument binding is possible and other hand arrow functions have no argument binding.

3) Regular functions are construable but arrow functions are not constructible.

There are two methods to remove duplicate content from an array such as using a temporary array and a separate index.

1. Using indexOf() Method

const getUnique = (arr) => {     
    let uniqueArr = [];    
     for(let i of arr) {
        if(uniqueArr.indexOf(i) === -1) {
            uniqueArr.push(i);
        }
    }
    console.log(uniqueArr);
}
const array = [1, 2, 3, 2, 3,4,5];
getUnique(array);

Answer

[ 1, 2, 3, 4, 5 ]

2. Using Set Method

let chars = ['A', 'B', 'A', 'C', 'B'];
let uniqueChars = [...new Set(chars)];
console.log(uniqueChars);

Answer

[ 'A', 'B', 'C' ]