javascript Interview Questions

Memoization in JavaScript refers to a performance optimization technique where results of expensive function calls are stored in a cache, so that subsequent calls with the same input can return the precomputed result instead of recalculating it. This approach is particularly useful for functions that involve repetitive computations, as it helps to reduce the overall execution time by avoiding redundant operations. Memoization can be implemented using various data structures such as objects or maps to store the results of previous computations.

Callbacks in JavaScript serve the purpose of executing a function after another function has completed its operation. They enable you to manage asynchronous operations by providing a function as a parameter to another function. When the first function finishes its task, it "calls back" the provided function to perform further actions. This is especially useful in scenarios like fetching data from an API, handling events, or working with timers, ensuring code executes in the desired sequence without blocking the main thread.

The == and === operators in JavaScript are used for comparison but behave differently:

1. == (Equality Operator): This operator compares two values for equality but performs type coercion. If the values being compared are of different types, JavaScript will attempt to convert them to the same type before making the comparison. For example, 0 == '0' returns true because the string '0' is converted to a number before comparison.

2. === (Strict Equality Operator): This operator compares both the value and type of the operands. No type conversion is done, so the values must be of the same type for the comparison to return true. For example, 0 === '0' returns false because one is a number and the other is a string.

In JavaScript, the temporal dead zone refers to the time span between the entering of the scope and the initialization of a variable declared with let or const. During this period, any reference to the variable results in a ReferenceError, as it is not yet in a usable state, even though it exists in the scope.

var declares variables with function or global scope, allowing them to be hoisted. let provides block-scoped variables and avoids hoisting issues. const is also block-scoped like let but is used for defining constants, ensuring that the variable's value cannot be reassigned after initialization.

External JavaScript files allow for code reusability, better organization, and separation of concerns. They reduce HTML file size, improve maintainability, and enable caching, which can boost page load performance by avoiding repetitive script loading.

A closure occurs when a function retains access to its lexical scope, even after the outer function has completed execution. This allows the inner function to continue accessing variables from the outer function, enabling the creation of private variables and functions.

The prototype design pattern involves creating objects based on a prototype, allowing for the inheritance of properties and methods from a base object. This pattern is commonly used in JavaScript, where objects can inherit directly from other objects, facilitating shared behavior without requiring deep inheritance hierarchies.

You can dynamically create and insert elements into a webpage using JavaScript like this:

let newElement = document.createElement('div');
newElement.textContent = "This is a new component.";
document.body.appendChild(newElement);

A constructor function in JavaScript is used to create and initialize new objects. It sets up the object's properties and methods when a new instance is created using the new keyword, enabling the reuse of the same structure for multiple objects.

An IIFE is a function that is defined and executed immediately after its creation. It is often used to create a private scope, ensuring that variables inside the function do not leak into the global namespace. Syntax example:

(function() {
  // Code here
})();

A WeakMap is a collection of key-value pairs where the keys are objects and the values can be any type of data. Unlike regular Maps, keys in a WeakMap are weakly held, meaning if no other references to the key exist, it can be garbage collected, preventing memory leaks.

Async/await and generators are both mechanisms for handling asynchronous operations in JavaScript, but they differ in how they achieve this.

• Async/await is built on Promises, providing a cleaner syntax for dealing with asynchronous code. The async function returns a promise, and await pauses the function's execution until the promise resolves, making the code appear synchronous. Async/await simplifies chaining asynchronous actions and error handling using try/catch.

• Generators, on the other hand, are a language feature that allows functions to pause and resume execution using yield. While they can handle asynchronous flows, they need to be manually managed with iterators or in combination with promises to achieve similar results to async/await. The flow control with generators is more manual, using the next() method to advance the execution.

Thus, while both can handle asynchronous operations, async/await is considered more intuitive and concise, while generators offer more flexibility but require more explicit management.

The keywords var and let are both used for variable declarations, but their scope and behavior differ:

• var has function-scoped behavior, meaning that when a variable is declared with var inside a function, it is accessible throughout the entire function, including in blocks like if or for. Variables declared with var can also be redeclared within the same scope, which can lead to unexpected behaviors.

• let, on the other hand, has block-scoping, meaning that it is confined to the block in which it is defined, such as loops or conditional statements. This makes let more predictable in scenarios where you want to limit the variable's scope to a specific block of code. Additionally, let cannot be redeclared within the same scope, offering stricter rules to avoid accidental mistakes.

Hoisting in JavaScript is a behavior in which variable and function declarations are moved to the top of their containing scope during the compilation phase, before the code is executed. This means you can reference variables and functions in your code even before they are defined.

For function declarations, hoisting allows the entire function definition to be available throughout its scope. For example:

console.log(greet()); // Outputs: "Hello, World!"

function greet() {
    return "Hello, World!";
}

Strict mode is a feature in JavaScript that was introduced in ECMAScript 5 to enforce stricter parsing and error handling of code. It is invoked by placing "use strict"; at the beginning of a script or a function. With strict mode enabled, JavaScript's behavior is altered in the following ways.

• Prevents the use of undeclared variables: Variables must be declared before being used, eliminating silent errors.
• Disallows certain syntax: Certain JavaScript features like with or assigning values to read-only properties are prohibited.
• Eliminates silent failures: Errors that would normally be ignored (e.g., assigning a value to a non-writable property) will now throw exceptions.
• Safer eval(): In strict mode, eval does not create variables in the surrounding scope.

Strict mode helps in writing cleaner and more maintainable code by catching errors early.

In JavaScript, each object contains an internal reference to another object referred to as its prototype. The prototype object contains methods and properties that are shared among all instances of a particular object type. This enables inheritance in JavaScript, where an object can access properties and methods defined in its prototype.

• When accessing an object's property, JavaScript initially verifies whether the property is directly present on the object. If not, it looks for it in the object's prototype, and then in the prototype’s prototype, continuing up the chain until it reaches Object.prototype.

This allows for efficient code reuse, as objects can share methods and properties defined in their prototypes without copying them directly.

This is a basic implementation of the binary search algorithm:

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;

  while (left <= right) {
    const mid = Math.floor((left + right) / 2);

    if (arr[mid] === target) {
      return mid; // Target found at index mid
    } else if (arr[mid] < target) {
      left = mid + 1; // Target is in the right half
    } else {
      right = mid - 1; // Target is in the left half
    }
  }

  return -1; // Target not found
}

This function returns the index of the target if it exists in the sorted array arr, otherwise returns -1.

A Promise in JavaScript is an object representing the eventual completion or failure of an asynchronous operation. It allows asynchronous code to be written in a more synchronous style, making it easier to manage.

• A promise can be in one of three states:
  • Pending: The operation is still in progress.
  • Fulfilled: The operation completed successfully.
  • Rejected: The operation failed.

Promises help in avoiding "callback hell," providing cleaner code by chaining .then() for success or .catch() for error handling. They also allow asynchronous operations to be handled sequentially using async/await syntax.

A WeakSet in JavaScript is a specialized collection designed to hold objects using weak references. Unlike a Set, which maintains strong references to its elements, a WeakSet employs weak references. This means that if no other part of the code references an object stored in a WeakSet, the object becomes eligible for garbage collection, helping to manage memory efficiently.

Key Features of WeakSet:

• It exclusively stores objects, disallowing primitive values like numbers or strings.
• Objects in a WeakSet are weakly referenced, so they do not block garbage collection.
• Operations such as add(), has(), and delete() are supported for managing the stored objects.
• WeakSet lacks methods like clear() and iteration capabilities, as it does not provide a way to traverse its contents.