What is a closure, and when would you use one?
A closure is a function that retains access to its lexical scope even when invoked outside that scope. It powers data privacy, function factories, memoization, and the module pattern.
JavaScript Interview Questions for Frontend Developers
A focused list of the JavaScript interview questions that actually come up in frontend loops — from core language mechanics to the coding tasks you'll be asked to implement live. Each comes with a concise answer, and you can practice the hands-on ones in a real browser-based editor with test cases.
Core JavaScript language questions
The fundamentals interviewers open with to gauge how well you understand the language itself.
What is the difference between var, let, and const?
`var` is function-scoped and hoisted with an initial value of undefined; `let` and `const` are block-scoped and live in the temporal dead zone until declared. `const` cannot be reassigned, though objects it points to remain mutable.
How does the `this` keyword work?
`this` is determined by how a function is called: the global object (or undefined in strict mode) for plain calls, the owning object for method calls, the bound value for call/apply/bind, the new instance for constructors, and the enclosing lexical `this` for arrow functions.
What is the difference between == and ===?
`==` performs type coercion before comparing, while `===` compares value and type with no coercion. Prefer `===` to avoid surprising results like 0 == "" being true.
Explain prototypal inheritance.
Objects link to a prototype object via their internal [[Prototype]]. Property lookups walk this prototype chain until the property is found or the chain reaches null, which is how shared methods and inheritance work in JavaScript.
What is hoisting?
Declarations are processed before code runs: var and function declarations are hoisted (var initialized to undefined, functions fully available), while let/const are hoisted but unusable until their declaration line.
Asynchronous JavaScript questions
Async behavior is the single most common area where frontend candidates trip up. Expect deep follow-ups here.
Explain the event loop.
The call stack runs synchronous code; async callbacks wait in queues. After the stack empties, the event loop drains all microtasks (promises, queueMicrotask) before taking the next macrotask (setTimeout, I/O, events).
What is the difference between microtasks and macrotasks?
Microtasks (promise callbacks) run to completion immediately after the current task and before rendering; macrotasks (timers, events) run one per loop iteration. Microtasks always have priority.
How do promises improve over callbacks?
Promises give a single object representing a future value with chainable .then/.catch, flattening nested "callback hell" and centralizing error handling.
What does async/await do under the hood?
async functions return promises; await pauses execution until a promise settles, scheduling the rest of the function as a microtask. It is syntactic sugar over promise chains with synchronous-looking control flow.
What is the difference between debounce and throttle?
Debounce waits until activity stops for N ms before firing (good for search inputs); throttle fires at most once per N ms during continuous activity (good for scroll and resize handlers).
Functions, objects, and scope questions
These separate engineers who memorized syntax from those who understand mechanics.
What is the difference between call, apply, and bind?
call and apply invoke a function with an explicit this (call takes comma-separated args, apply takes an array); bind returns a new function with this permanently set, without calling it.
What is currying?
Transforming a function of multiple arguments into a sequence of single-argument functions, e.g. add(1)(2)(3). It enables partial application and reusable, configurable functions.
How do you deep clone an object?
Use structuredClone(obj) in modern environments. For older targets, a recursive clone works, or JSON.parse(JSON.stringify(obj)) — though the JSON approach drops functions, undefined, Dates, and circular references.
What is the difference between a shallow and deep copy?
A shallow copy (spread, Object.assign) duplicates only the top level; nested objects are still shared by reference. A deep copy recursively duplicates every level so the copy is fully independent.
Hands-on JavaScript coding questions
Frontend loops increasingly ask you to implement these live. Practice them in a real editor rather than just reading the answer.
Implement debounce and throttle.
Tests closures, timers, and this/argument forwarding with apply.
Flatten a deeply nested array.
Tests recursion versus iterative stack approaches and handling arbitrary depth.
Write a deep clone function.
Tests recursion, type checks, and handling arrays, objects, and circular references.
Implement Promise.all from scratch.
Tests promise mechanics, counting resolved values, and short-circuiting on the first rejection.
Build a memoize / cache wrapper.
Tests closures and serializing arguments into a cache key.
Implement event delegation.
Tests bubbling, event.target matching, and why delegation scales better than per-node listeners.
Frequently asked questions
What are the most common JavaScript interview questions for frontend developers?
Closures, the event loop, the difference between var/let/const, how this works, promises and async/await, prototypal inheritance, and hands-on tasks like implementing debounce, deep clone, or Promise.all.
How should I prepare for a JavaScript interview?
Master the core concepts (closures, scope, async, prototypes), then practice implementing common utilities by hand in a real editor with test cases — recall under pressure matters more than recognition.
Are JavaScript interview questions different for frontend roles?
Yes. Frontend loops emphasize the event loop, DOM and browser APIs, async UI patterns, and component-style coding far more than the abstract algorithm puzzles common in backend interviews.
How many JavaScript questions should I practice before an interview?
Quality beats quantity. Working through 30–50 representative questions across fundamentals, async, and coding patterns — and being able to explain your reasoning — covers most frontend loops.