Question 1

How do closures work in JavaScript?

Accepted Answer

A closure is a function that retains access to variables from its outer scope even after the outer function has returned. Real-life uses: - Data privacy — expose only a controlled API, keeping state hidden - Function factories — create pre-configured functions (multipliers, loggers)

Question 2

What is prototypal inheritance?

Accepted Answer

In JavaScript, objects inherit from other objects via prototypes. Every object has a hidden Prototype link. Property lookup walks up the chain until it either finds the property or reaches null. The very top of the prototype chain is Object.prototype, whose own Prototype is null.

Question 3

What are map, filter, and reduce?

Accepted Answer

map transforms each element and returns a new array of the same length. filter returns a new array of elements that pass a predicate. reduce folds all elements into a single accumulated value. Writing a reduce polyfill tests your understanding of the accumulator pattern, initial value edge cases, and callback signature (accumulator, current, index, array).

Question 4

What are call, bind, and apply?

Accepted Answer

call(ctx, ...args) — invokes the function immediately with explicit this and individual arguments. apply(ctx, argsArray) — same as call, but arguments are passed as an array. bind(ctx, ...args) — returns a new function permanently bound to ctx. Does not invoke immediately. Key difference: call/apply execute now; bind creates a bound copy for later.

Question 5

What are callbacks, promises, and async/await?

Accepted Answer

Callbacks — functions passed as arguments, called when async work finishes. Can cause callback hell (deeply nested code). Promises — represent an eventual value. Chainable with .then / .catch, avoiding deep nesting. async/await — syntactic sugar over Promises. Makes async code look and read like synchronous code.

Question 6

What is debouncing?

Accepted Answer

Debouncing delays a function call until after a specified quiet period. Every new call resets the timer. The function only executes once the user stops triggering it. Classic use case: search input — only fire an API call after the user stops typing for 300ms.

Question 7

Flatten a nested array

Accepted Answer

Recursively walk each element: if it is an array, recurse into it; otherwise keep it. You can also use flat(Infinity) natively, but interviewers expect the manual recursive solution.

Question 8

Implement a throttle function

Accepted Answer

Throttle ensures a function executes at most once per interval, unlike debounce which waits for a pause. Edge cases to handle: - First call should fire immediately - Trailing call (the last burst call should still eventually fire) - Correct this context preservation - Timer cleanup on leading call

Question 9

Implement a polyfill for Promise

Accepted Answer

A Promise has three states: pending, fulfilled, rejected. Rules: - State is immutable once settled (can only change from pending) - .then always returns a new Promise - Handlers queued on a pending promise fire when it settles - .then chaining must propagate both resolved values and rejections correctly

Question 10

Write a curried version of a function

Accepted Answer

Currying transforms a multi-argument function into a chain of single-argument functions. When the accumulated argument count reaches fn.length, the original function is invoked. Distinction: currying always produces unary functions; partial application pre-fills some (but not necessarily all) arguments.

Question 11

How does JavaScript work under the hood?

Accepted Answer

JavaScript is single-threaded and uses an event loop to handle async work. - Call Stack — executes synchronous code - Microtask queue (higher priority): Promise .then, queueMicrotask — drained fully before any macrotask - Macrotask queue (lower priority): setTimeout, setInterval, I/O callbacks Order: synchronous → all microtasks → one macrotask → all microtasks → … repeat

Question 12

How can you implement a retry mechanism for fetching data?

Accepted Answer

Wrap the fetch in a loop. On failure, wait with exponential backoff (2^attempt × baseDelay) before retrying. After the final attempt, re-throw so callers can handle the error.

Question 13

Implement a delay

Accepted Answer

A delay helper wraps setTimeout in a Promise, enabling clean await delay(ms) syntax inside async functions. The example below waits 1 second — change 1000 to 10000 for 10 seconds.

Question 14

Deep clone an object

Accepted Answer

Use a WeakMap to track already-cloned objects and detect circular references. For each value: - Primitives (null, undefined, strings, numbers, booleans) → return as-is - Arrays → clone recursively element by element - Objects → clone own keys recursively Avoid JSON.parse(JSON.stringify(...)) — it drops undefined, Function, and circular refs.

Question 15

Convert a nested object into a flat key-value pair dictionary

Accepted Answer

Recursively walk the object, accumulating the dot-joined path. When a value is a plain non-null object (and not an array), recurse deeper. Otherwise emit the path → value pair.

Question 16

Explain inheritance in JavaScript

Accepted Answer

ES5 inheritance relies on three steps: 1. Constructor stealing — call the parent constructor with Parent.call(this) inside the child to copy own properties. 2. Prototype chaining — Child.prototype = Object.create(Parent.prototype) to inherit methods. 3. Fix the constructor — reset Child.prototype.constructor = Child.

Question 17

Implement an infinitely curried addition function

Accepted Answer

Without empty parentheses: Override valueOf/toString on the returned function so JavaScript coerces it to a number automatically (e.g. with unary +). With empty parentheses (add(1)(2)(3)()): Return the sum when called with no arguments — a sentinel pattern.

Question 18

Design an LRU Cache for Autocomplete

Accepted Answer

Hint: Use a JavaScript Map — it preserves insertion order, giving you O(1) LRU tracking without a doubly-linked list. - Cache hit: map.delete(key) then map.set(key, value) to move it to the "most recently used" end. - Cache miss: fetch, then insert. If map.size = maxSize, evict map.keys().next().value (the first entry = least recently used). You do not need a doubly-linked list — Map insertion order does the work for you.

Question 19

DAG Task Scheduler with Concurrency Limit

Accepted Answer

Hint: This is a topological sort + bounded concurrency problem. 1. Compute the in-degree of every task (number of unfinished prerequisites). 2. Seed a ready queue with all zero-in-degree tasks. 3. Dispatch up to concurrencyLimit tasks from the ready queue simultaneously. 4. When a task finishes, decrement in-degree of its dependants. Those that hit 0 join the ready queue. 5. Resolve when all tasks are complete. Watch out for: correct completion detection, not spawning over the limit, and tasks with no dependants.

Question 20

Implement Asynchronous Map with Concurrency Limit (mapLimit)

Accepted Answer

Hint: Think of a sliding window of active tasks. 1. Start the first limit tasks immediately, each tracking its own input index. 2. Pre-allocate a results array of inputs.length and track a completed counter. 3. When task at index i finishes → store result at resultsi, increment completed, then start the next un-started input (if any). 4. When completed === inputs.length → call callback(results). Key invariant: outputs must be in input order regardless of which tasks finish first.