JavaScript Interview Questions (2026): By Level, With Model Answers

var is function-scoped and hoisted; let/const are block-scoped with a temporal dead zone, and const forbids reassignment (though objects it points to stay mutable).

=== compares without type coercion; == coerces types first, which produces surprising results. A good answer defaults to ===.

Falsy values are false, 0, "", null, undefined, NaN; everything else is truthy, including [] and {}.

A function that retains access to variables from the scope it was created in, even after that scope has returned; the basis for data privacy and callbacks.

undefined means a variable has been declared but not assigned; null is an explicit “no value.” They know typeof null is the historical "object".

It is determined by how a function is called: the object before the dot, the global/undefined in plain calls, bound explicitly with call/apply/bind, and lexically in arrow functions.

map returns a new transformed array, filter returns a subset, forEach returns nothing and is for side effects.

Serialise to and from JSON text; limits include losing functions, undefined, and Date becoming a string, plus failing on circular references.

Synchronous code runs on the call stack; async callbacks are queued and run when the stack clears, with microtasks (promises) draining before macrotasks (timers). They can predict logging order.

async/await is syntactic sugar over promises that reads synchronously; errors are caught with try/catch instead of .catch(). They know await only pauses the async function, not the whole program.

Promise.all for all-or-nothing, Promise.allSettled when you need every result regardless of failures; awaiting in a loop serialises them unnecessarily.

Objects delegate to a prototype via the prototype chain; property lookups walk that chain, and class is sugar over it.

All set this; call/apply invoke immediately (args list vs array), bind returns a new bound function.

Debounce delays until activity stops (e.g. search input); throttle caps the rate (e.g. scroll handlers). They match the technique to the use case.

Forgotten timers and listeners, closures holding large objects, detached DOM nodes, and unbounded caches or global variables.

They return one of their operands, not a boolean; ?? only falls back on null/undefined, unlike || which falls back on any falsy value.

Reduce main-thread work, split and lazy-load bundles, avoid layout thrash, debounce expensive handlers, and move heavy computation to Web Workers — after profiling.

ES modules are static and tree-shakeable with live bindings; CommonJS is dynamic and synchronous. They understand bundling and interop concerns.

A generational, mark-and-sweep collector; short-lived objects are collected cheaply in the young generation. They avoid retaining references unnecessarily.

To move CPU-bound work off the main thread and keep the UI responsive, communicating via message passing since there is no shared DOM access.

Functions that can pause and resume with yield, useful for lazy sequences, custom iterators and controlled async flows.

try/catch around awaits, handling rejected promises, a global unhandledrejection handler, and never swallowing errors silently.

A shallow copy (spread, Object.assign) copies top-level references; nested objects are shared. Deep copies need structuredClone or a recursive approach.

Clear module boundaries, pure functions, consistent state management, TypeScript or JSDoc types, and tests. They think in architecture, not files.