Advanced JavaScript Interview Questions and Answers

Advanced JavaScript Interview Questions and Answers, naukri notice

1. Explain hoisting in JavaScript. How does it work?

Hoisting in JavaScript refers to the behavior of moving variable and function declarations to the top of their respective scopes during the compilation phase.

This means that variables and functions can be used before they are declared in the code. However, only the declarations are hoisted, not the initializations.


var x = 5;

// Output: undefined

The given code is interpreted as:

var x;
x = 5;

// Output: undefined

2. What are closures in JavaScript? Explain with an example of their usage.

Closures in JavaScript are functions that have access to variables from their outer lexical environment, even after the outer function has finished executing.

A closure is created when an inner function is returned from an outer function and maintains references to its outer variables. Here's an example:


function outerFunction() {
    var x = 10;
    function innerFunction() {
        console.log(x); // Accessing the outer variable
    return innerFunction;

var closure = outerFunction();

// Output: 10

In the above example, the "innerFunction" function has access to the x variable, even though it is defined in the "outerFunction" function.

3. What is the event loop in JavaScript? How does it handle asynchronous operations?

The event loop is a mechanism in JavaScript that handles asynchronous operations. It continuously checks the event queue and executes tasks in a non-blocking manner. Now, let's see how it works:

  • When an asynchronous operation (e.g., API request, timer, or event listener) is encountered, it is placed in the event queue.

  • The event loop repeatedly determines whether the call stack is empty.

  • If the call stack is empty, it takes the next task from the event queue and pushes it onto the call stack for execution.
  • This process repeats, allowing the JavaScript engine to handle multiple asynchronous operations concurrently without blocking the main thread.

4. How does prototypal inheritance work in JavaScript? Explain the prototype chain.

Prototypal inheritance in JavaScript is a mechanism by which objects can inherit properties and methods from other objects. Each object has an internal link to another object called its prototype. If a property or method is not found in an object, the JavaScript engine looks for it in the prototype of that object, forming a chain of prototypes called the prototype chain.

The prototype chain is traversed when accessing a property or method. If the property or method is not found in the current object, the engine continues the search in its prototype, and so on until the property/method is found or until the end of the prototype chain is reached (with null as the last prototype).

5. What is the difference between null and undefined in JavaScript?

In JavaScript, null and undefined are two distinct primitive values with different meanings:

  • undefined represents a variable that has been declared but has not been assigned a value.

  • null represents the intentional absence of any object value. It is often used to indicate that a variable or object property should have no value or an empty value.

6. What are promises in JavaScript? How do they help in asynchronous programming?

Promises are objects in JavaScript that represent the eventual completion (or failure) of an asynchronous operation and allow you to write asynchronous code in a more readable and manageable way.

Promises have three states: pending, fulfilled, or rejected.

They provide methods such as .then() and .catch() to handle the resolved value or catch any errors. Promises help avoid callback hell and make it easier to write and reason about asynchronous code.

7. What are generators in JavaScript? How are they different from regular functions?

Generators are a special type of function in JavaScript that can be paused and resumed, allowing for the generation of a sequence of values over time. They are denoted by using an asterisk (*) after the function keyword. Generators use the yield keyword to pause the function execution and return a value. They can be resumed later to continue execution from where it left off. Unlike regular functions, generators maintain their own state and allow for lazy evaluation of values.

8. What is the difference between null, undefined, and undeclared in JavaScript?

  • null: It is a value that represents the intentional absence of any object value.

  • undefined: It is a value that indicates a variable has been declared but has not been assigned a value, or a function parameter was not provided, or an object property does not exist.

  • undeclared: It refers to a variable that has been used without being declared using var, let, or const. If you are trying to access an undeclared variable then the will result will be in a ReferenceError.

9. What are arrow functions in JavaScript? How do they differ from regular functions?

Arrow functions are a concise syntax for writing function expressions in JavaScript. They provide a shorter and more readable syntax compared to regular functions. Some of the key differences are:

  • Arrow functions do not bind their own "this" value but instead, inherit it from the enclosing scope (lexical this).

  • Arrow functions do not have their own arguments object. Instead, you can use the rest parameters (...args) to access function arguments.

  • Arrow functions cannot be used as constructors with the new keyword.

10. What is event delegation in JavaScript? How does it work?

Event delegation is a technique in JavaScript where instead of attaching event listeners to individual elements, you attach a single event listener to a common parent element. This parent element then handles events on behalf of its child elements.

When an event occurs, it bubbles up the DOM tree, and the parent element can identify the target element that triggered the event using the property.

This technique is useful for handling events on dynamically added or frequently changing elements, improving performance, and reducing memory usage.

11. Explain the concept of currying in JavaScript.

Currying is a technique in JavaScript where a function with multiple arguments is transformed into a sequence of functions, each taking a single argument. This allows you to create more specialized functions and partially apply arguments.


function sum(x) {
    return function (y) {
        return x + y;

var addSum = sum(5);

// Output: 8

In the example above, the sum function takes an argument x and returns another function that takes an argument y and adds x and y.

By partially applying the sum function with 5, we create a new function addSum that adds 5 to any given number.

12. What are the differences between let, const, and var in JavaScript?

  • var has function scope and can be redeclared and reassigned within its scope.

  • let has block scope and allows you to declare variables that are limited in scope to the block, statement, or expression in which they are used. It can be reassigned but not redeclared within its scope.

  • const also has block scope, but it represents a constant value that cannot be reassigned once defined. However, for objects and arrays declared with const, their properties or elements can still be modified.

13. Explain the concept of memoization in JavaScript.

Memoization is an optimization technique used to cache the results of expensive function calls and reuse them when the same inputs occur again. This can significantly improve the performance of functions that are computationally expensive or have repetitive calculations.

Now let's see an example of a memoization implementation for a function that calculates Fibonacci numbers:


function memoization(func) {
  var cache = {};
  return function (n) {
    if (n in cache) {
      return cache[n];
    else {
      var output = func(n);
      cache[n] = output;
      return output;

function fibo(n) {
  if (n <= 1) {
    return n;
  return fibo(n - 1) + fibo(n - 2);

var memoizedFibo = memoization(fibo);

// Output: 55

In the example above, the memoization function takes a function func as an argument and returns a memoized version of it. The cache object is used to store the results of previous function calls, and if the same input occurs again, the cached result is returned instead of recalculating it.

14. What is the purpose of the "this" keyword in JavaScript? How is it determined?

The "this" keyword in JavaScript is a reference to the object on which a method is being called or the context in which a function is executed. Its value is determined at runtime based on how a function is invoked. Some different ways this can be determined:

  • Global context: In non-strict mode, this refers to the global object (e.g., window in browsers, global in Node.js). In strict mode, this is undefined.

  • Function context: When a function is called as a method of an object, this refers to that object.

15. What are modules in JavaScript? How do you implement modules?

Modules in JavaScript allow you to organize code into reusable, encapsulated units. They help in creating maintainable and scalable code by providing a way to separate concerns and avoid global namespace pollution.

Prior to the introduction of ES modules, JavaScript used various module systems like CommonJS and AMD. With ES modules, you can use the import and export keywords to import and export functionality between modules.


// math.js
function add(a, b) {
    return a + b;

module.exports = add;

// main.mjs
import add from './math.js';
console.log(add(2, 3));

// Output: 5

In the example above, the add function is exported from the math.js module and imported in the main.mjs module using the import statement.

16. What is the async/await syntax in JavaScript? How does it work?

async/await is a modern syntax introduced in JavaScript that simplifies asynchronous programming and makes it look more like synchronous code. The async keyword is used to define an asynchronous function, and the await keyword is used to pause the execution of an asynchronous function until a promise is resolved or rejected.


function late(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));


async function func() {
  await late(3000);


In the example above, the func function is marked as async, allowing the use of await inside it. The execution of func pauses at the await statement until the delay promise resolves after a 3000ms delay. This allows for more readable and sequential code, similar to synchronous programming.

17. Explain the concept of event bubbling and event capturing in JavaScript.

Event bubbling and event capturing are two mechanisms that describe the order in which events are propagated in the DOM tree. When an event occurs on an element, it is handled first by the innermost element and then propagated outward to its ancestors. This is called event bubbling.

On the other hand, event capturing is the opposite: the event is handled starting from the outermost element and then propagated inward to the target element.

By default, event handling in JavaScript follows the bubbling phase. You can use the addEventListener method with the useCapture parameter set to true to switch to the capturing phase. For example:


element.addEventListener('click', handle, true); // Event capturing

element.addEventListener('click', handle, false); // Event bubbling (default)

Event delegation (mentioned earlier) relies on event bubbling to handle events on parent elements instead of individual child elements.

18. What are the different ways to create objects in JavaScript?

In JavaScript, there are several ways to create objects:

  • Object literals: Objects can be created using object literals with key-value pairs. For example: const obj = { key: value };

  • Constructor functions: Objects can be created using constructor functions with the new keyword. For example:

function Person(username) {
  this.username = username;

const person = new Person('Raju');

// Output: Person { username: 'Raju' }

Object.create(): Objects can be created using the Object.create() method.

19. What is the event loop in JavaScript? How does it work?

The event loop is a critical component of JavaScript's concurrency model. It's responsible for handling asynchronous operations and ensuring that JavaScript remains single-threaded. The event loop continuously checks the call stack and the event queue.

Now, let's see how it works:

  • When an asynchronous operation is encountered, it's offloaded to the browser's APIs (e.g., Web APIs, timers).

  • Once the operation is complete, a corresponding callback is placed in the event queue.

  • The event loop checks the call stack and, if empty, moves the callbacks from the event queue to the call stack for execution.

  • This process continues, allowing JavaScript to handle multiple asynchronous operations without blocking the main thread.

It's important to note that JavaScript has a "run-to-completion" behavior, meaning that each task in the event queue is fully executed before moving on to the next task.

20. What is the purpose of the bind() method in JavaScript? How does it work?

The bind() method is used to create a new function that has a specific this value and, optionally, pre-set arguments. It allows you to control the execution context of a function. When bind() is called on a function, it returns a new function that, when invoked, has its this value set to the provided value.


const myObj = {
  name: 'Raju',
  message: function () {
    console.log(`Hello, ${}!`);

const mainFunc = myObj.message.bind(myObj);

// Output: Hello, Raju!

In the example above, the bind() method is used to bind the message function to the myObj object. When mainFunc() is called, it executes with the "this" value set to myObj, resulting in the expected output.

Advanced Javascript Interview Questions and Answers PDF: Download Now

Post a Comment

* Please Don't Spam Here. All the Comments are Reviewed by Admin.

Top Post Ad

Below Post Ad