3-Month Frontend Interview Plan

Implement findLast and findLastIndex — scan an array from the end for the last element matching a predicate.

Implement Array.prototype.myAt — return the element at a given index, supporting negative offsets from the end.

Implement Array.prototype.every — return false as soon as an element fails the predicate, true when empty.

Implement Array.prototype.filter from scratch as a method on the array prototype.

Implement Array.prototype.flat — flatten nested arrays to a given depth (default 1, Infinity for all levels), dropping holes.

Implement Array.prototype.forEach — run a callback on each element as (value, index, array), skipping sparse holes.

Implement Array.prototype.includes — test membership with SameValueZero so NaN matches, honoring negative fromIndex.

Implement Array.prototype.indexOf — first index of a value by strict equality, supporting a negative fromIndex.

Implement Array.prototype.some — return true as soon as any element passes the predicate, false when empty.

Implement a custom Array.prototype.square method that returns a new array with each value squared.

Implement a function that splits an array into groups of a given size, with the last group holding the remainder.

Implement a function that constrains a number to lie within an inclusive minimum and maximum range.

Implement a function that returns a new array with every falsy value stripped out.

Implement a function that consolidates rows sharing the same user into a single grouped record.

Implement a function that returns the elements from the first array that do not appear in the second.

Implement a function that drops trailing array elements as long as a predicate keeps returning truthy.

Implement a function that drops leading array elements as long as a predicate keeps returning truthy.

Implement a function that replaces array elements with a given value between an optional start and end index.

Implement a function that checks whether an array contains any duplicate numbers.

Implement a function that returns the index of the first array element matching a predicate, or -1 if none match.

Implement a function that returns the index of the last array element matching a predicate, or -1 if none match.

Implement a function that returns the single missing number from a sorted sequence of integers.

Find the first failing version among 1..n where a monotonic isBad check flips from false to true — a boundary binary search using the fewest checks.

Implement a function that builds an object from an array of [key, value] pair tuples.

Implement a function that checks whether a number lies within a half-open range, swapping bounds when needed.

Implement a function that returns the unique values present in every input array.

Implement lodash keyBy — index a collection into an object keyed by an iteratee's return, keeping the last item for each key.

Implement a function that joins an array of strings into a grammatical list with commas and a conjunction.

Implement Map.groupBy — group an iterable into a Map whose keys can be any value, preserving key insertion order.

Implement a function that returns the array element producing the largest value when run through an iteratee.

Implement a function that computes the arithmetic mean of the numbers in an array.

Implement a function that returns the array element producing the smallest value when run through an iteratee.

Implement nth — return the element at index n, counting from the end when n is negative, so head is nth(0) and last is nth(-1).

Implement a function that computes the maximum profit obtainable from one buy and one sell of a stock.

Implement a function that finds two numbers in an array that add up to a given target.

Implement a function that builds an array of numbers from start up to end, stepping by a given increment.

Implement a function that builds an array of numbers from end down to start in descending order.

Implement String.prototype.repeat — join a string n times, throwing RangeError on a negative or infinite count.

Implement lodash sumBy and meanBy — total and average an array by an iteratee that maps each element to a number.

Implement take and takeWhile — grab the leading n elements, or the leading run that satisfies a predicate.

Implement a function that wraps occurrences of a search term within a string in highlight markup.

Implement times — invoke a function n times and collect the results into an array.

Implement a function that returns a new array with duplicate values removed while preserving original order.

Implement without — return a copy of an array with the given values excluded, matched by SameValueZero.

Implement lodash xor — return the values that appear in exactly one of the given arrays, with duplicates removed.

Move all zeroes to the end of an array in place while keeping the non-zero elements in their original order.

Implement a setInterval wrapper that returns a function which stops the interval when invoked.

Implement a setTimeout wrapper that returns a function you can call to cancel the pending callback.

Implement a function that composes functions right-to-left so the output of each feeds into the next.

Implement a function that, given several values, returns a function that yields each one in turn and loops forever.

Implement a function that delays invoking another function until a specified period of inactivity has passed.

Implement a factory that takes a starting integer and returns a function that returns the next value on each call.

Implement a function that returns the count of arguments passed to it at call time.

Implement a function that wraps a callback so it runs at most one time and reuses that result thereafter.

Run async tasks in sequence, feeding each result into the next, stopping the chain on the first rejection.

Implement a function that returns a promise resolving after the specified number of milliseconds.

Implement a cache whose entries expire a fixed time after their last access, not after being set.

Buffer bursty streamed text and emit it one character at a time at a steady cadence, with flush and stop controls.

Implement a function that limits how often a wrapped function can be invoked within a time window.

Implement Array.prototype.myReduce — the reduce method from scratch, including the empty-array + initial-value edge cases.

Build an analytics client that queues tracked events, flushes them in batches, and retries failed sends with backoff.

Implement an async debounce that resolves only the newest call and discards the results of superseded ones.

Implement an async memoize that caches results by key for a TTL and coalesces concurrent calls for the same key.

Buffer events and flush them in batches when a size threshold or a max-wait timer is reached.

Implement before and after — cap how many times a function runs, or delay invoking it until the Nth call.

Implement a simplified cva that builds class names from base styles, variant tables, and default values.

Implement a wrapper that intercepts console.log calls and records their arguments for later inspection.

Implement a function that transforms a multi-argument function into a chain of single-argument calls.

Implement a flexible curry where each call can supply any number of arguments until the original arity is reached.

Extend debounce with cancel and flush methods to abort or immediately invoke pending calls.

Extend debounce with a maxWait option that forces a call after a maximum delay even under constant activity.

Build a DI container that resolves a service dependency graph, caches singletons, and detects circular dependencies.

Implement a function that counts the number of unique paths a robot can take from the top-left to bottom-right of an m by n grid.

Implement flow — compose functions left to right so each output feeds the next.

Implement Function.prototype.myBind — return a new function with a fixed `this` and optional preset arguments.

Build an axios-style client whose request and response interceptors transform each call as it passes through the chain.

Implement a function that wraps a callback so it runs at most N times and returns the last result thereafter.

Implement a factory that returns a counter object with methods to read, increment, decrement, and reset its value.

Implement a function that caches results of a single-argument function so repeat calls return instantly.

Implement a memoize helper that caches results for functions called with any number and type of arguments.

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.