Frontend Interview Questions & Coding Practice

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.