Advanced JavaScript Interview Questions and Answers

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.

Example

                                                    
let person = {

    name: "Ankit",

    profession: {

        name: "content writer"

    }

};

Object.freeze(person);

person.profession.name = "content writer";

console.log(person);

Output { name: 'Ankit', profession: { name: 'content writer' } }

Now, using Deep Freeze for the object,

function deepFreeze(object) {

    let propNames = Object.getOwnPropertyNames(object);

    for (let name of propNames) {

        let value = object[name];

        object[name] = value && typeof value === "object" ?

            deepFreeze(value) : value;

    }

    return Object.freeze(object);

}

let person = {

    name: "Ankit",

    profession: {

        name: "content writer"

    }

};

deepFreeze(person);

person.profession.name = "content writer";
                                                

The "use strict" is not a statement, rather a literal expression that is vital to your code as it presents a way for voluntarily enforcing a stricter parsing and error handling process on your JavaScript code files or functions during runtime. Most importantly, it just makes your code very easy to manage.

Here are some of the benefits of using use strict expression at the beginning of a JS source file:

• It makes debugging a lot easier by making the code errors that are ignored generate an error or throw exceptions.
• It prevents the most common error of making an undeclared variable as a global variable if it is assigned a value.
• It does not allow the usage of duplicate property names or parameter values.

Asynchronous programming means that the program engine runs in an event loop. Only when blocking operation is required, a request is started, and the code runs without blocking the result.

This is vital in JavaScript because it is a very natural fit for the user interface code and very efficient performance-wise on the server end.

The WeakMap object is basically a collection of key or value pairs where the keys are weakly referenced. It provides a way for extending objects from the outside without meddling into the garbage collection.

Here are some use cases of Weakmap objects:

• Maintaining private data about a specific object while only giving access to people having a reference to the Map.
• Safekeeping of data related to the library objects without making any changes to them or incurring any overhead.
• Keeping of data related to the host objects such as DOM nodes in the browser.

The main difference between these two is when you are using inheritance. It is much more complicated using inheritance in ES5, while the ES6 version is simple and easy to remember.

ES6 Class:

class Person {
   constructor(name) {
      this.name = name;
   }
}

ES5 function constructor:

function Person(name) {
   this.name = name;
}

In JavaScript, generators are those functions which can be exited and re-entered later on. Their variable bindings shall be saved across the re-entrances. They are written using the function* syntax.

The Generator function should be used when:

• You can choose to jump out of a function and let the outer code determine when to jump back in the function.
• The control of the asynchronous call can be executed outside of your code.

JavaScript is a high-level, multi-paradigm programming language which conforms to the ECMAScript specification. Read our list of advanced javascript interview questions to get a deep understanding of this language.

One of the drawbacks of creating a true private method in JavaScript is that they are highly memory consuming. A new copy for each method is created for every instance.

Example:

var Employee = function (name, company, salary) {
    this.name = name || "";
    this.company = company || "";
    this.salary = salary || 5000;
    var increaseSlary = function () {
        this.salary = this.salary + 1000;
    };
    this.dispalyIncreasedSalary = function() {
       increaseSalary();
       console.log(this.salary);
   };
};
var emp1 = new Employee("Amar","Mars",3000);

Here, while creating each variable, each instance makes a new copy of emp1, emp2, and emp3 in IncreaseSalary. Thus, making it inefficient for your server end.

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.

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).

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:

Example

                                                    
var the_fibonacci_series = function (n)

{

  if (n===1)

  {

    return [0, 1];

  }

  else

  {

    var a = the_fibonacci_series(n - 1);

    a.push(a[a.length - 1] + a[a.length - 2]);

    return a;

  }

};

console.log(the_fibonacci_series(9));