JavaScript Interview Questions & Coding Challenges

How the call stack, microtask queue, and macrotask queue decide execution order — with the output-prediction questions interviewers love.

What a closure really is, why loops with var trip people up, and how closures power memoization, once(), and module patterns.

The four binding rules, arrow-function behavior, and the lost-this bugs that call, apply, and bind exist to fix.

The prototype chain, __proto__ vs prototype, and what class syntax actually does under the hood.

Object.groupBy, Promise.withResolvers, Set methods, iterator helpers, and the other additions worth knowing in interviews.

The ES2024 way to create a promise you settle from outside — and how to implement the deferred pattern it replaces.

map, filter, take, and drop directly on iterators (ES2025): lazy evaluation without loading everything into an array.

Implement groupBy from scratch, then meet the ES2024 built-ins — including the null-prototype result and Map.groupBy for object keys.

Implement debounce from scratch, with leading/trailing options and the classic search-input use case.

Implement throttle and know exactly when to reach for it instead of debounce (scroll, resize, mousemove).

Rebuild setTimeout on top of requestAnimationFrame to show you understand timer scheduling and drift.

Implement setInterval with setTimeout recursion — and fix the drift problems of the native version.

Track and clear every active timeout and interval — a utility question about monkey-patching globals safely.

Implement a spec-faithful Promise with then chaining, state transitions, and async resolution.

Implement Promise.all: aggregate results in order, fail fast on the first rejection.

Implement allSettled: wait for every promise and report per-promise status objects.

Implement Promise.any with AggregateError semantics: first success wins, all failures reject.

Implement Promise.race and use it for the timeout pattern every senior interview touches.

Implement finally correctly: pass values through, and don't swallow rejections.

Run N async tasks with at most K in flight — the production-style p-limit pattern, including ordering and failure trade-offs.

Cancel fetch requests, add timeouts with AbortSignal.timeout, and write abortable async utilities.

Retry a failing async operation N times with backoff — a small function with big production implications.

Process a large list of async tasks in fixed-size sequential batches to protect downstream services.

Run async tasks one after another and understand why reduce-with-promises works.

Fire all tasks at once and gather results — plus what parallel really means on a single thread.

First settled task wins: build the primitive behind timeouts and fastest-source fetching.

Convert error-first callback APIs into promise-returning functions, like Node's util.promisify.

Cache in-flight and resolved requests to deduplicate API calls — with cache invalidation trade-offs.

Transform f(a, b, c) into f(a)(b)(c): the classic closure exercise, with arity handling.

The harder follow-up: support _ placeholders so arguments can arrive in any order.

Compose functions left-to-right into a pipeline — the one-liner with a lot of interview depth.

Pre-fill leading arguments of a function — partial application, and how it differs from currying.

Guarantee a function runs exactly once and returns its cached result forever after.

Cache function results by argument key — and discuss cache-key strategy and memory trade-offs.

A single-slot memoizer that remembers only the previous call — the pattern behind React's useMemo.

When to use the built-in structuredClone, where it fails (functions, prototypes), and how it compares to JSON round-tripping.

Recursively clone nested objects and arrays, handling cycles with a WeakMap.

Structural equality for nested data: type checks, key comparison, and recursion done right.

Flatten arbitrarily nested arrays recursively and iteratively — then compare with Array.prototype.flat.

Turn nested objects into dot-path keys ({ 'a.b.c': 1 }) and back — the transform behind form libraries and analytics events.

Use a Proxy to support arr[-1] like Python — a practical introduction to Proxy traps.

Implement call from scratch: temporary method assignment and why Symbol keys avoid collisions.

Same trick as call but with an arguments array — plus the subtle differences that interviewers probe.

Implement bind including partial application and the new-operator edge case most candidates miss.

Implement myNew(Constructor, ...args): prototype linking, this binding, and the return-object override rule.

Walk the prototype chain by hand, then meet Symbol.hasInstance — and learn where instanceof lies to you.

Copy enumerable own properties across sources, with getter evaluation and null-target errors.

The equality that fixes === for NaN and -0: tiny implementation, classic trivia follow-ups.

Reimplement typeof with Object.prototype.toString and learn why typeof null === 'object'.

Serialize values by hand: undefined, functions, cycles, and all the special cases JSON defines.

Write a small recursive-descent parser — the deepest polyfill question in the set.

Implement reduce including the no-initial-value case and empty-array TypeError.

Strip whitespace without regex catastrophes — and enumerate what counts as whitespace.

Split source text into tokens — a warm-up for parsing questions like JSON.parse.

Implement on, off, once, and emit — the pub/sub pattern behind Node streams and countless libraries.

Implement delegate(root, selector, handler) with closest() — one listener for a thousand rows, and why frameworks did exactly this.

Model back/forward/push navigation with an index and a stack — the core of every router.

Turn real DOM into a plain-object tree — the first half of understanding how React represents UI.

Rebuild real DOM from the virtual tree, completing the render pipeline.

Diff two virtual trees and apply minimal DOM mutations — the reconciliation step that makes the virtual DOM worth having.

Rebuild the classnames utility: strings, arrays, objects, and nested combinations.

A mini Redux store with Immer-style draft mutations — reducers, subscriptions, and immutability.

O(1) get/put with least-recently-used eviction — the Map insertion-order trick, and the linked-list version interviewers ask about.

Debounce, cancellation, and stale-response guards composed into a search box that never shows the wrong results.

IntersectionObserver, in-flight guards, end-of-data states, and the sentinel pattern — the pagination question every feed team asks.

A dependency-free rating component: event delegation, hover preview vs committed state, keyboard support, and the ARIA pattern.

A concurrency-limited scheduler with priorities and cancellation — the pool question upgraded to the API-design round.