Interview Questions

JavaScript runs on one thread with a call stack. Slow operations are handed to the host (browser, libuv); when they finish, their callbacks go into queues. When the stack is empty, the event loop drains the microtask queue (promise callbacks) completely, then runs one macrotask (timer, I/O), then microtasks again. This is why 1; setTimeout(2); Promise.resolve().then(3); 4 prints 1, 4, 3, 2 — and why a long loop freezes the page.

What they are really testing: The single most asked mid-level question. A follow-up will nest a promise inside a timeout.

(1) obj.method() → the object. (2) A plain call → undefined in strict mode, the global object otherwise. (3) new Fn() → the new object. (4) Arrow functions have no own this — they use the enclosing scope's. call/apply/bind set it explicitly. The value depends on how the function is called, not where it is written.

Every object has a link to a prototype object. Property lookup checks the object, then its prototype, then the prototype's prototype, until null. Methods on Array.prototype are found this way by every array. class syntax sets this chain up: methods go on Class.prototype, and extends links prototypes.

Mostly sugar over constructor + prototype, with real differences: classes must be called with new, their bodies are strict mode, methods are non-enumerable, class declarations are not hoisted (TDZ), and they support #private fields, static blocks and super properly. The object model underneath is unchanged.

Microtasks: promise reactions, queueMicrotask, MutationObserver — drained completely after every task, before rendering. Macrotasks: timers, I/O, UI events — one per loop turn. A microtask that queues another microtask runs before any timer, which can starve rendering if abused.

all: all fulfil → array; rejects fast on the first rejection. allSettled: waits for all, never rejects, gives status per item. race: first to settle wins, either way — used for timeouts. any: first to fulfil wins; rejects only if all reject, with an AggregateError.

Parallel: start them all, then await Promise.all(promises). Sequence: for (const x of items) await work(x). A common bug is items.forEach(async …), which starts everything and awaits nothing. Rate-limited parallelism needs a small pool (p-limit or a hand-rolled queue).

A promise that rejects with no handler attached. Browsers log it; Node terminates the process. Avoid it by giving every promise an owner: await inside try/catch, a trailing .catch, and an explicit .catch(log) on fire-and-forget calls. Register process.on("unhandledRejection") as a last resort to log and exit cleanly.

function* returns an iterator; each yield hands out a value and pauses until next() is called. Uses: lazy sequences (infinite or huge, consumed on demand), custom iterables via *[Symbol.iterator], and pipelines like take(map(source)) that do no work until consumed. Async generators (for await) model streams.

=== on objects compares identity — two equal-looking objects are not equal. Deep equality means recursively comparing contents. Options: JSON.stringify for plain data (order-sensitive, drops undefined), a library (lodash isEqual), or a test framework's toEqual. React relies on identity for change detection, which is why immutable updates matter.

Frameworks detect change by reference (prev !== next, O(1)) rather than comparing contents. Mutating keeps the reference, so nothing re-renders; and shared mutable state is a bug source. setTasks(prev => prev.map(t => t.id === id ? { ...t, done: true } : t)) creates a new array and a new object for the changed item only.

Both limit how often a function runs. Debounce waits until calls stop for N ms, then runs once — search-as-you-type. Throttle runs at most once per N ms while calls continue — scroll handlers. Both are closures holding a timer or a timestamp.

Caching a function's results by its arguments so repeated calls are O(1). Right for pure, expensive functions with repeated inputs (Fibonacci, layout computations, selectors). Wrong when the function has side effects, when inputs rarely repeat (the cache just eats memory), or when arguments are objects you cannot key reliably.

Map: any key type, guaranteed insertion order, size, directly iterable, no inherited keys, better for frequent add/delete. Object: string/symbol keys, JSON-serialisable, dot syntax. Use objects for records with known fields; Maps for dictionaries keyed by data.

V8 uses Timsort (merge sort + insertion sort on runs), O(n log n), and the spec has required stability since ES2019, so equal items keep their order — you can sort by one key then another. The default comparator is string-based; always pass one for numbers. sort mutates; toSorted does not.

A Map whose keys must be objects and are held weakly: if nothing else references the key, the entry can be garbage-collected. Use it to attach metadata or private state to objects you do not own (DOM nodes, third-party instances) without leaking memory. It is not iterable, by design.

The browser's same-origin policy blocks a page from reading responses from another origin unless that server sends Access-Control-Allow-Origin (and, for non-simple requests, answers a preflight OPTIONS). It protects users, not servers; the fix is on the server (or a proxy through your own backend). Nothing client-side bypasses it.

localStorage: ~5 MB of strings per origin, persists, synchronous, never sent to the server. sessionStorage: same but per tab, cleared on close. Cookies: small, sent with every request to the domain, can be HttpOnly (invisible to JS — right for session tokens) and Secure. Never put secrets in local/sessionStorage.

Removing unused exports from the bundle. ESM imports are static — analysable without running the code — so a bundler can see that import { a } from "lib" never uses b and drop it. CommonJS require is a dynamic call, so nothing can be dropped safely.

CJS: require/module.exports, synchronous, dynamic, Node's original system. ESM: import/export, static, asynchronous loading, top-level await, works in browsers, tree-shakeable. ESM can import CJS; CJS can only reach ESM with dynamic import() (or require in Node 22+ for sync-compatible modules).

Throw (or next(err)) from handlers; in Express 5 rejected promises from async handlers are forwarded automatically. Register an error middleware with four arguments last: it maps known errors (a custom class with a status) to responses, logs unknown ones, and never leaks stack traces to clients.

A well-known symbol naming the method that makes an object iterable. If obj[Symbol.iterator]() returns an iterator (an object with next() returning { value, done }), then for…of, spread, destructuring and Array.from all work on it. Writing it as a generator method is the easy way.

DNS, TCP and TLS handshakes, an HTTP request; the server returns HTML. The browser parses it into the DOM, fetches CSS (render-blocking) and scripts (blocking unless defer/module), builds the render tree, lays out, paints. DOMContentLoaded fires when parsing is done, load when subresources are. Performance work is about shortening that critical path.

Two async operations finishing in the wrong order — a search box where the response for "ab" arrives after "abc" and overwrites it. Prevent it by ignoring stale responses (a request id or a cancelled flag in the closure), aborting the previous request with AbortController, or serialising with a queue.

Undeclared assignments throw instead of creating globals; this in plain calls is undefined instead of the global object; writes to read-only properties throw; duplicate parameter names and octal literals are errors; eval and arguments are restricted. It is automatic in modules and classes, which is why it rarely needs writing today.