Common JavaScript Interview Questions

This topic collects the JavaScript questions that show up most often in technical interviews, organized as a quick-reference FAQ. Each question is paired with a concise, accurate answer you can use to check your own understanding or rehearse out loud. Read through them once for comprehension, then use the Quick Reference section to drill the one-liners right before an interview.

var is function-scoped (or globally scoped) and is hoisted with an initial value of undefined, allowing it to be referenced (but not meaningfully used) before its declaration line. let and const are block-scoped and are hoisted into a 'temporal dead zone' — they exist in scope but throw a ReferenceError if accessed before their declaration. const additionally prevents reassignment of the binding (though objects/arrays assigned to a const can still be mutated internally).

A closure is a function that retains access to variables from its enclosing lexical scope even after that outer function has returned. Closures are how JavaScript implements private state and factory functions — e.g. a makeCounter() function that returns an increment function which still remembers its own count variable.

Hoisting is the JavaScript engine's behavior of processing variable and function declarations during the compile phase, before code executes line by line. Function declarations are hoisted completely (usable before their textual position). var declarations are hoisted with value undefined. let/const declarations are hoisted but remain in the temporal dead zone until their line executes, so accessing them earlier throws a ReferenceError.

The event loop is the mechanism that lets single-threaded JavaScript handle asynchronous work. Synchronous code runs first on the call stack. When it's empty, the event loop drains the microtask queue completely (Promise callbacks, queueMicrotask) before taking a single task from the macrotask queue (setTimeout callbacks, I/O, UI events), then repeats. This is why Promise.resolve().then(...) always runs before a setTimeout(..., 0) callback.

javascript console.log('A'); setTimeout(() => console.log('B'), 0); Promise.resolve().then(() => console.log('C')); console.log('D'); Output: A, D, C, B. Synchronous statements (A, D) run immediately on the call stack. The Promise callback is queued as a microtask and the setTimeout callback as a macrotask; the event loop drains all microtasks (C) before processing the next macrotask (B`), regardless of the 0ms delay.

this is determined by how a function is called, not where it's defined (except for arrow functions). As a plain function call, this is undefined in strict mode (or the global object otherwise). As a method call (obj.method()), this is the object before the dot. With new, this is the newly created instance. With call/apply/bind, this is explicitly set. Arrow functions have no own this — they lexically inherit it from their enclosing scope.

=== (strict equality) compares both value and type with no conversion, so 1 === '1' is false. == (loose equality) performs type coercion before comparing, so 1 == '1' is true. Best practice is to default to === and only use == when coercion is explicitly desired (e.g. value == null to check for both null and undefined).

Every JavaScript object has an internal link ([[Prototype]], accessible via Object.getPrototypeOf or the deprecated __proto__) to another object it can delegate property lookups to. If a property isn't found on the object itself, the engine walks up this prototype chain. class syntax and constructor functions with .prototype are just ergonomic ways to set up this chain — under the hood, class B extends A makes B.prototype's prototype equal to A.prototype.

undefined means a variable has been declared but not assigned a value, or a property/argument simply doesn't exist. null is an explicit assignment representing 'intentionally no value.' They are loosely equal (null == undefined is true) but strictly unequal (null === undefined is false), and typeof null famously returns 'object' — a long-standing quirk of the language.

A Promise represents the eventual result (or failure) of an asynchronous operation as a first-class object with states pending, fulfilled, or rejected. Unlike raw callbacks, Promises can be chained with .then(), composed with Promise.all/Promise.race, and avoid 'callback hell' (deep nesting). They also standardize error propagation — a rejection skips to the next .catch() automatically instead of requiring manual error-first checks at every step.

Arrow functions ((a, b) => a + b) have no own this, arguments, or super — they capture these lexically from the enclosing scope, making them ideal for callbacks that need to preserve the outer this. They also cannot be used as constructors (new throws), have no prototype property, and cannot be used as generator functions.