JavaScript Interview Questions

Primitive types store value directly on the Stack (stack memory) and are immutable. Reference types store an address/pointer on the Stack pointing to a mutable object located in the Heap memory.

Hoisting is the mechanism in JavaScript where variable and function declarations are moved to the top of their containing scope during the compilation phase, before execution begins.

The Temporal Dead Zone is the period/state between block entry and the line of declaration where variables declared with let and const cannot be accessed.

Scope is the actual physical boundary where a variable is accessible. Lexical Environment is the internal structure containing local variables and a reference to its parent Lexical Environment.

== (Loose Equality) checks for value equality and performs implicit type coercion. === (Strict Equality) checks for both value and type without coercion.

undefined means a variable has been declared but not yet assigned a value. null is an intentional assignment representing "no value" or an empty object reference.

A falsy value is a value that translates to false when evaluated in a boolean context. All other values are truthy.

A pure function always returns the exact same output for the same input and produces no side effects. An impure function can yield different outputs or modify external state.

A shallow copy duplicates the top-level structure, keeping reference pointers to nested objects. A deep copy recursively clones every nested value and reference, decoupling them entirely.

const prevents reassignment of a variable reference. Object.freeze() makes the properties of an object read-only and prevents adding or removing properties.

Template literals are string literals delimited with backticks (`), allowing multi-line strings, string interpolation, and tagged templates.

Arrow functions do not have their own this context (they inherit it lexically), do not have an arguments object, and cannot be used as constructors.

The spread operator (...) unpacks items from an array/object. The rest operator collects multiple separate arguments or items into a single array structure.

Destructuring is a clean syntax that allows unpacking properties from objects or values from arrays directly into individual variables.

Map allows keys of any data type (including objects/functions) and maintains insertion order, whereas Object keys must be Strings or Symbols.

A closure is the combination of a function bundled together with references to its surrounding state (the lexical environment). It lets an inner function access the outer scope even after the outer function has finished executing.

Execution Context is the environment in which code is evaluated and executed. The Call Stack is a LIFO (Last In, First Out) data structure used to manage execution contexts.

A prototype is an object linked to every function/object in JS where properties and methods can be inherited. The Prototype Chain is the mechanism of traversal from child prototypes upward up to Object.prototype to resolve a property.

this refers to the object currently executing the function, evaluated entirely at execution runtime based on how the function was invoked.

call invokes a function immediately, specifying this and passing arguments individually. apply does the same but accepts arguments as an array. bind returns a new function with this locked, to be called later.

A Promise is an object representing the eventual completion or failure of an asynchronous operation, existing in three states: Pending, Fulfilled, or Rejected.

Async/Await is syntactic sugar built on top of Promises. It allows writing asynchronous code that looks and behaves like synchronous sequential code.

The Event Loop is the runtime mechanism that continuously monitors the Call Stack and moves callbacks from the Callback and Microtask Queues to the stack when the stack is empty.

Event delegation is a design pattern where you attach a single event listener to a parent element instead of individual child nodes, leveraging event bubbling.

Debouncing limits the execution of a function until a specified idle duration has elapsed since its last invocation.

Throttling enforces a maximum frequency rate of execution, ensuring a function fires at most once per defined time window.

Capturing (trickling) goes top-down from parent elements down to the target. Bubbling goes bottom-up, from the clicked child target up through parents to the global window root.

Classes are syntactic sugar built over JavaScript's existing prototype-based inheritance model, providing cleaner OOP structure.

ES6 modules use import and export statements. They load statically, execute strictly, and help build decoupled tree-shakeable codebases.

A Set is an unordered collection of unique values, while an Array is an ordered collection allowing duplicate values.

Currying is a pattern where a function taking multiple arguments is transformed into a series of nested functions that take only one argument each.

Memoization is an optimization technique that caches the return values of expensive function computations based on their input parameters.

A polyfill is fallback JS code used to provide modern feature support to older browser clients lacking that capability.

Promise.all rejects immediately if any promise in the array fails. Promise.allSettled waits for all inputs to complete/fail and returns their status arrays.

A callback is a function passed as an argument to another function. Callback Hell is the term for deeply nested, unreadable callback structures that complicate control flow.

Iterators are objects defining a standard next() output sequence structure. Generators are special functions that can pause/resume execution via the yield keyword, producing iterators under the hood.

A memory leak occurs when items are no longer used by the application but remain allocated in the Heap because references to them are still active.

Garbage Collection is an automated process in the JS engine that frees up memory occupied by objects that are no longer reachable from the root execution contexts.

WeakMap and WeakSet are collections that only accept objects/symbols as keys, maintaining "weak" references to those objects so they can be collected by Garbage Collection if no other references exist.

A Proxy wraps an object, letting you intercept and customize fundamental operations like reading, writing, and modifying properties.

Reflect is a built-in object providing methods to call interceptable JavaScript operations, mirroring proxy interceptors to simplify forwarding operations.

Web Workers are browser APIs allowing JavaScript code to execute in background background threads, independent of the main user-interface thread.

V8 parses JavaScript into an Abstract Syntax Tree (AST), compiles it to Bytecode via the 'Ignition' interpreter, and optimizes it using 'TurboFan' into fast machine code based on hot performance loops.

A custom function that returns a Promise, iterates through the array of promises, resolves each, and collects the results in a matching-index array. If any promise rejects, it rejects immediately.

A custom utility function that recursively copies all elements of objects and arrays, preserving depth and references while decoupling original entities.

A Class representing a custom Promise implementation that captures status, value, and callbacks, handling asynchronous execution flows manually.

Tail Call Optimization is a compiler mechanism where the engine avoids allocating a new stack frame if the last action of a function is a direct call returning another function.

A Symbol is a unique and immutable primitive value, primarily used to create hidden, collision-free object property keys.

A Shadow DOM is a self-contained, encapsulated DOM tree detached from the main document DOM, preventing styles and structures from leaking in or out.

Tricks usually target unexpected behaviors like 0.1 + 0.2 !== 0.3 (floating-point binary representation), NaN !== NaN, and automatic semicolon insertion side-effects.