Frontend Interview Questions & Coding Practice

Extend memoize with a custom key resolver and cache controls (.clear() and .delete(key)).

Build atom-based state with primitive and derived atoms that recompute and notify subscribers on change.

Build a Redux core with createStore, combineReducers, and applyMiddleware over a subscribe/dispatch loop.

Implement negate, overEvery, and overSome — build new predicates by combining existing ones.

Implement partial and partialRight — pre-fill some of a function's arguments, with placeholder support.

Implement a function that combines the results of two promises into a single value using a merger function.

Implement a function that races a promise against a timer and rejects if the promise doesn't settle in time.

Implement a function that wraps a Node-style error-first callback function so it returns a promise.

Extend promisify so the wrapped function can override the resolved value via a custom override hook.

Implement a sliding-window rate limiter that decides which task timestamps fit within the allowed quota.

Implement the curried Redux middleware chain with working thunk and logger middleware.

Build memoized selectors that recompute only when their input selections change by reference.

Wrap an async call with retries, backoff, and a per-attempt timeout so transient failures recover.

Implement an interval helper that exposes start, pause, and resume controls while preserving elapsed progress.

Implement a small schema library that validates primitives and flat object shapes with composable rules.

Build a tiny schema validation library that supports chainable min and max rules on primitive types.

Implement a function that decides whether a string can be broken into a sequence of words from a given dictionary.

Build reactive signals with automatic dependency tracking so computed values and effects update on change.

Implement a Singleton class that always hands back the same instance no matter how many times you construct it.

Return cached data instantly, serving stale values while revalidating them in the background.

Implement a curried sum function that accepts numbers one call at a time and returns the running total when invoked with none.

Build a small test runner that supports nested describe suites and reports tests with their full spec names.

Extend a tiny test runner with beforeEach and afterEach hooks that are inherited from outer suites.

Extend throttle with cancel and flush methods plus leading and trailing edge options.

Build a schema-driven form validator with composable per-field rules, cross-field checks, and async validators that report all errors.

Extend curry with placeholder support, so arguments can be supplied in any position across calls.

Run a queue of tasks in time slices, yielding control between them so the main thread stays responsive.

Implement a curry helper that turns a variadic function into one that can be called repeatedly with any number of arguments.

Build an in-memory query builder inspired by Drizzle with table helpers, filters, sorting, and pagination.

Extend an in-memory query builder inspired by Drizzle with select projections and column aliases.

Implement an async map that processes an array with a bounded number of in-flight tasks.

Implement an async middleware composer that chains functions Koa-style, threading a shared context through next.

Return an array where each entry is the product of every element except the one at that index, without division and in O(n).

Implement Array.prototype.myConcat — merge arrays and values into a new array, spreading nested arrays one level deep.

Implement Array.prototype.find and findLast — return the first or last element matching a predicate, or undefined.

Implement Array.prototype.flatMap — map each element, then flatten the mapped results by one level.

Implement Array.prototype.myMap — return a new array with the callback applied to each element, skipping holes.

Implement Array.prototype.myReduce — fold an array down to one value, handling sparse arrays and missing initial values.

Implement Array.prototype.reduceRight — fold an array right-to-left, throwing on an empty array with no initial value.

Implement Array.prototype.splice — remove and insert elements in place, returning the removed ones, with clamped indices.