Master JavaScript: Killer FAQ to Ace Next Interview Now

Explain the differences between let, var, and const in JavaScript.

In JavaScript, let, var, and const are used to declare variables. The main differences between them are in their scope and their ability to reassign values:

  1. var: Variables declared with var are function-scoped, meaning they are only accessible within the function in which they are declared. If a variable is declared with var outside of any function, it becomes a global variable, accessible throughout the entire program. Variables declared with `var can be reassigned a new value at any point in the program.
  2. let: Variables declared with let are block-scoped, meaning they are only accessible within the block in which they are declared. This means that variables declared with let can be reassigned a new value within the same block, but they cannot be accessed outside of that block.
  3. const: Variables declared with const are also block-scoped, like let. However, once a variable is declared with const, its value cannot be reassigned. Attempting to reassign a value to a const variable will result in a syntax error

How does event bubbling and capturing work in JavaScript?

In JavaScript, event bubbling and capturing refer to the two ways in which events propagate through the Document Object Model (DOM) when an event is fired on an element.

  1. Event Bubbling: When an event is fired on an element, it first propagates from the element that the event was fired on, up through its parent elements, all the way up to the document object. This is known as event bubbling. In other words, when an event is fired on an element, it bubbles up through the ancestors of that element, triggering any event listeners that are registered on those ancestors.
  2. Event Capturing: The opposite of event bubbling is event capturing. In this method, the event propagates from the top of the DOM tree, down to the element that the event was fired on. Event listeners registered for capturing are called before event listeners registered for bubbling. This method is less commonly used than bubbling, but it can be useful in certain situations.

By providing the appropriate value to the addEventListener method, you can select the event propagation method. The event type is the first argument, followed by the event listener. The event listener’s capture or bubbling mode is determined by the third argument, a boolean value, which is optional. The event listener will be for capturing if the value is true and for bubbling if it is false.

explain callbacks, promises and async/await

  1. Callbacks: A callback function is a function that is passed as an argument to another function and is invoked after the completion of that function. In JavaScript, callbacks are often used to handle the results of an asynchronous operation, such as an HTTP request. For example, a callback function can be passed as an argument to an XMLHttpRequest object’s onreadystatechange event, and it will be invoked when the response is received. The callback function can then process the response and update the application accordingly.
  2. Promises: Promises are a more recent addition to JavaScript and they provide a more elegant way to handle asynchronous operations. A promise is an object that represents the eventual completion or failure of an asynchronous operation, and its resulting value. A promise has three states: pending, fulfilled and rejected. The promise object has then, catch and finally methods, these methods allow the developer to handle the promise resolution and rejection in a more elegant way.
  3. Async/Await: The async/await keywords are a more recent addition to JavaScript and they provide an even more elegant way to handle asynchronous operations. async functions are a way to write asynchronous code that looks and behaves like synchronous code. An async function can contain one or more await expressions, which pause the execution of the function until a promise is fulfilled or rejected. This allows you to write asynchronous code that is easy to read and understand.

Example With Callbacks, promises and async/await

Here is an example of using callbacks to handle the results of an asynchronous operation:

function getData(callback) {
    // Perform an asynchronous operation
    setTimeout(() => {
        const data = "Data retrieved";
    }, 1000);

getData(function (data) {

In this example, the getData function performs an asynchronous operation (in this case, a timeout) and then invokes the callback function that was passed as an argument, passing the resulting data as an argument.

Here is the same example using Promises:

function getData() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            const data = "Data retrieved";
        }, 1000);

getData().then((data) => {

In this example, the getData function returns a new promise object, which is resolved with the resulting data after the asynchronous operation completes. The then method is used to handle the resolved value of the promise.

Here is the same example using async/await:

async function getData() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            const data = "Data retrieved";
        }, 1000);

async function main() {
    const data = await getData();


In this example, the getData function returns a promise just like before. The main function is declared as async and the await keyword is used before the getData call. This allows the main function to wait for the promise to be resolved and the value is stored in the variable data.

It’s important to note that the first example of using callbacks is a typical JavaScript pattern, but as the number of nested callbacks grows, it can be challenging to reason about. The code is easier to read and reason about because promises and async/await offer a more elegant way to handle asynchronous operations.

Explain how closure and the JavaScript execution context works.

In JavaScript, a closure is a function that has access to the variables in the scope in which it was defined, even after that scope is no longer active. This allows you to preserve state across multiple function calls and to create function objects with unique behavior.

Here’s an example of a closure in JavaScript:

Copy codefunction makeCounter() {
    var count = 0;
    return function() {
        return count++;
var counter = makeCounter();
console.log(counter()); // logs 0
console.log(counter()); // logs 1
console.log(counter()); // logs 2

In this example, the makeCounter function returns a function that increments and returns a count. When the makeCounter function is called, it creates a new variable count, which is accessible within the returned function. Even though the makeCounter function has completed executing, the returned function still has access to the count variable through closure.

A closure is created when a function is defined inside another function and the inner function references a variable from the outer function. The outer function’s variables are kept in memory as long as the inner function (the closure) is still in use. The closure holds a reference to the inner function’s variables, not the value of them.

What is JavaScript Execution Context?

The environment in which JavaScript code is executed is described by the abstract concept known as JavaScript execution context. In JavaScript, a new execution context that contains variables, objects, and functions that are accessible to the function is created each time a function is called. This value, which depends on how the function is called, is also part of the execution context.

The JavaScript execution context is created in two phases:

  1. Creation Phase: In this phase, JavaScript engine creates the Global Object, this and sets up memory space for variables and functions in the current context.
  2. Execution Phase: In this phase, the JavaScript engine executes the code, assigns values to variables and executes functions.

When the execution context is created, JavaScript engine creates a scope chain that is used to look up variables. The scope chain is a linked list of scopes, where the first scope is the most local scope and the last scope is the global scope.

Describe how you would implement a JavaScript module pattern.

The JavaScript module pattern is a way to organize and structure code by encapsulating it within a single object, and making certain variables and functions private. Here is an example of how you might implement a JavaScript module pattern:

const myModule = (function () {
    // Private variables and functions
    let privateVariable = "I am a private variable";
    function privateFunction() {
        console.log("I am a private function");

    // Public variables and functions
    return {
        publicVariable: "I am a public variable",
        publicFunction: function () {
            console.log("I am a public function");

In this illustration, the module is defined using an immediate anonymous function call. An object containing the public variables and functions is returned after the function defines private variables and functions. The public variables and functions are the only ways to interact with the module; the private variables and functions cannot be accessed from outside the module.

Describe the JavaScript event loop and how it works.

The JavaScript event loop is a mechanism that allows JavaScript to execute code asynchronously. It is used to handle events that occur in the browser, such as user input, network requests, and timers.

The event loop has two main components: the call stack and the message queue.

  1. The call stack: The call stack is a data structure that stores the execution context of the JavaScript code. When a function is called, its execution context is pushed onto the call stack. When the function returns, its execution context is popped off the stack. The call stack is responsible for maintaining the order of function calls.
  2. The message queue: The message queue is a data structure that stores messages that represent events that have occurred. When an event occurs, a message is added to the message queue. The event loop constantly checks the message queue to see if there are any new messages. If the message queue is not empty and the call stack is empty, the event loop will take the first message in the queue and push its associated function call onto the call stack.

The call stack and message queue are continuously inspected by the event loop as it runs in a loop. The event loop pulls the subsequent message from the queue and pushes its associated function call onto the call stack if the call stack is empty. Up until there are no more messages in the queue, this process keeps going.

Because of the event loop, JavaScript is a non-blocking language that can handle several events at once. This allows the JavaScript code to keep running while awaiting a response from another source, which is especially helpful when working with user input, network requests, and timers.

What is an execution context?

In JavaScript, an execution context is an abstract concept that represents the environment in which code is executed. It includes information about the code that is currently executing, such as the current scope, variables and functions that are available, and the value of this.

Each time a function is called, a new execution context is created and pushed onto the call stack. The execution context contains information about the function that is being executed, including the arguments that were passed to the function and any variables or functions that are defined within the function.

Each execution context also has an associated scope chain, which is a linked list of objects that defines the variables and functions that are available to the code within the execution context. The scope chain starts with the global object and includes any local variables and functions defined within the current function.

When a function returns or finishes executing, its execution context is removed from the call stack and the JavaScript engine continues executing the code in the next execution context on the stack.

What is the difference between null and undefined in JavaScript?

  1. undefined: A variable that has been declared but has not been assigned a value is undefined. An undefined variable does not point to any object or value, it represents that the variable has been declared but no value has been assigned to it yet. Also, when a function returns without any value, the function returns undefined.
  2. null: On the other hand, null is a value that is explicitly assigned to indicate that a variable or a property has no value. It is a value that is set to indicate that something has been intentionally left empty. It is often used to indicate the absence of an object or a value that is expected to be there.

How can you implement a debouncing function in JavaScript?

Debouncing is a technique that is used to limit the rate at which a function is called. It is often used in situations where a function is called multiple times in a short period of time, such as when handling user input or window resize events.

Here is an example of how you might implement a debouncing function in JavaScript:

function debounce(fn, delay) {
  let timer;
  return function() {
    timer = setTimeout(() => {
        fn.apply(this, arguments);
    }, delay);

The passed function’s execution is postponed by this implementation using the setTimeout function. The arguments for the debounce function are a function and a delay. The function substitutes an anonymous function for the original function and creates a timer variable in its place. To prevent any previous execution of the function, the timer variable is first cleared inside of this anonymous function. After that, a new timer is set with the specified delay, and the original function is then called with the appropriate context and arguments inside of the timer callback.

Here’s an example of how you might use the debounce function:

const myFunction = debounce(() => {
  console.log("Function called");
}, 1000);

// Listen for a button click event
document.getElementById("myButton").addEventListener("click", myFunction);

In this example, the debounced version of the function is assigned to the myFunction variable. When the button is clicked, the debounced function is called, and it will only execute the original function once every 1000 milliseconds (1 second) even if the button is clicked multiple times during that period.

How can you make an HTTP request using JavaScript?

There are several ways to make an HTTP request using JavaScript, but one of the most common methods is to use the XMLHttpRequest (XHR) object, which is built into most web browsers.

The XMLHttpRequest object provides a way to make HTTP requests from JavaScript code, and it can be used to retrieve data from a web server, send data to a web server, or both.

Here is an example of how to use the XMLHttpRequest object to make a GET request to a web server:

var xhr = new XMLHttpRequest();"GET", "", true);
xhr.onreadystatechange = function() {
    if (xhr.readyState === 4 && xhr.status === 200) {
        var data = JSON.parse(xhr.responseText);

In the example above, a new XMLHttpRequest object is created and the open method is used to initialize the request. The first parameter is the HTTP method (GET in this case), the second parameter is the URL to send the request to, and the third parameter is a boolean indicating whether the request should be made asynchronously or not.


The onreadystatechange event is used to handle the response from the server. The readyState property of the XMLHttpRequest object changes as the request is processed, and when it reaches the value 4, it means that the request is complete. The status property is used to check the status code of the response, which is 200 in this case, indicating that the request was successful.

Finally, the send method is used to send the request.

You can also make a POST request or any other type of request by just changing the first parameter of the open method.

Another way to make an HTTP request using JavaScript is using the Fetch API. It is a more modern and cleaner way to make HTTP request as well as it provides a better error handling mechanism.

  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));

It uses the fetch method which returns a promise and can be used to handle the response using the then method.

For security reasons, JavaScript code running on a web page is subject to the same-origin policy, which means that it can only make HTTP requests to the same domain as the web page. To access resources on other domains, you will need to use a technique such as CORS (Cross-Origin Resource Sharing) or JSONP (JSON with Padding).

You can find my details here –
You can also check out my repository:

Leave a Comment