JavaScript Interview Questions

var is function-scoped and hoisted (initialized as undefined); let and const are block-scoped and in the temporal dead zone until declared. const additionally prevents reassignment of the binding, though object properties can still be mutated.

Hoisting is JavaScript's behavior of moving declarations to the top of their scope during compilation. var declarations are hoisted and initialized as undefined; function declarations are fully hoisted; let and const are hoisted but not initialized, causing a ReferenceError if accessed before their declaration.

== performs type coercion before comparing (e.g., '5' == 5 is true), while === checks both value and type without coercion ('5' === 5 is false). Prefer === to avoid unexpected coercion bugs.

JavaScript has 7 primitive types: string, number, bigint, boolean, undefined, null, and symbol. Everything else is an object (including arrays, functions, and dates). typeof null returns 'object' — a known historical quirk.

A closure is a function that retains access to its outer lexical scope even after the outer function has returned. This enables patterns like data encapsulation, factory functions, and memoization.

this refers to the execution context of a function. In a regular function it depends on how the function is called (the calling object); in arrow functions it is lexically inherited from the surrounding scope. Methods like call, apply, and bind can explicitly set this.

The event loop continuously checks whether the call stack is empty; if so, it dequeues tasks from the callback queue (macrotasks) or the microtask queue and pushes them onto the stack. Microtasks (Promise callbacks) are always drained before the next macrotask, giving them higher priority.

undefined means a variable has been declared but not assigned a value, or a function parameter was not provided. null is an explicit assignment representing the intentional absence of a value. Both are falsy but null == undefined is true while null === undefined is false.

A Promise is an object representing the eventual completion or failure of an asynchronous operation, providing .then(), .catch(), and .finally() chaining instead of nested callbacks. Promises avoid 'callback hell', offer better error propagation, and compose well with async/await syntax.

async/await is syntactic sugar over Promises; an async function always returns a Promise, and await pauses execution of that function until the awaited Promise settles, then resumes with the resolved value. Under the hood the engine uses generator-like coroutines and the microtask queue.

Every JavaScript object has an internal [[Prototype]] link to another object. When a property or method is not found on an object, the engine walks up the prototype chain until it finds it or reaches null. ES6 classes are syntactic sugar over this prototype-based system.

All three set the this value of a function. call invokes the function immediately with arguments passed individually; apply invokes it immediately with arguments as an array; bind returns a new function with this permanently bound without invoking it immediately.

Arrow functions have a concise syntax and do not have their own this, arguments, super, or new.target bindings — they inherit these lexically. They cannot be used as constructors and are not suitable for object methods that need a dynamic this.

Event delegation attaches a single event listener to a parent element instead of multiple listeners on child elements, relying on event bubbling. When a child is clicked the event bubbles up to the parent, which checks event.target to determine the originating element — improving performance and handling dynamically added elements.

A shallow copy duplicates only the top-level properties; nested objects still share the same reference. A deep copy recursively duplicates all nested structures. Shallow copies can be created with Object.assign or spread; deep copies with structuredClone(), JSON.parse(JSON.stringify()) (with caveats), or libraries like Lodash's cloneDeep.

Debouncing delays a function's execution until after a specified idle period following the last invocation — useful for search-input handlers. Throttling ensures a function executes at most once per specified interval regardless of how often it is called — useful for scroll or resize handlers.

The TDZ is the period between entering a block scope and the point where a let or const variable is declared. Accessing the variable in this zone throws a ReferenceError, even though the declaration is technically hoisted.

Modern engines (V8, SpiderMonkey) primarily use mark-and-sweep: the GC marks all objects reachable from root references (globals, stack) and sweeps (frees) the rest. Generational collection separates short-lived (young/nursery) and long-lived (old/tenured) objects for efficiency.

WeakMap and WeakSet hold weak references to their object keys/values, meaning those objects can be garbage-collected even while held in the collection. They are useful for private data associated with DOM nodes or class instances without causing memory leaks, but they are not iterable and have no size property.

Macrotasks (setTimeout, setInterval, I/O callbacks) are queued in the task queue and processed one per event-loop iteration. Microtasks (Promise callbacks, queueMicrotask, MutationObserver) are queued in the microtask queue and all are drained completely after the current task and before the next macrotask, giving them priority over macrotasks.