Question 1

Explain Event Loop mechanics, detailing how microtasks and macrotasks are prioritized.

Accepted Answer

JavaScript is a single-threaded language, meaning it executes one instruction at a time on its Call Stack. The Event Loop is the runtime mechanism that coordinates asynchronous tasks.

When async operations (like network fetches, timers, or event listeners) complete, their callback handlers are queued in task queues rather than entering the Call Stack immediately. The Event Loop checks if the Call Stack is empty. If it is, it empties queues in a strict priority order:

1. Microtasks Queue: Contains promises (`.then`, `.catch`), queueMicrotask callbacks, and MutationObserver callbacks. This queue must be *entirely emptied* before the Event Loop moves to the next phase, even if new microtasks are appended during execution.
2. Rendering Pipeline: The browser updates styles, layouts, and paints if appropriate.
3. Macrotasks Queue (or simply Task Queue): Contains `setTimeout`, `setInterval`, `setImmediate` (Node.js), and user interactions. Only *one macrotask* is executed per tick, after which the loop immediately checks the microtasks queue again.

Understanding this is critical to avoid UI starvation bugs caused by recursive microtask creation.

Question 2

What is the difference between call, apply, and bind?

Accepted Answer

All three configure the `this` context for a function:
- `call()` invokes the function immediately, passing arguments individually: `fn.call(obj, arg1, arg2)`.
- `apply()` invokes the function immediately, passing arguments as an array: `fn.apply(obj, [arg1, arg2])`.
- `bind()` returns a new function copy with `this` permanently bound, which can be executed later.

Question 3

What is the difference between throttle and debounce, and how do they optimize performance?

Accepted Answer

Both restrict function execution frequency:
- Throttling guarantees a function runs at most once in a given duration (e.g. executing on resize events once every 100ms).
- Debouncing waits for a period of inactivity before executing (e.g. waiting for a user to stop typing before calling a search API).

Question 4

Explain prototypal chaining and the role of __proto__ versus prototype.

Accepted Answer

`prototype` is an object property present on constructors and classes, defining properties shared by all instances. `__proto__` is an internal instance accessor pointing to the object's prototype. Traversing the prototype chain traverses `__proto__` references until reaching `Object.prototype.__proto__` which is null.

Question 5

What is currying in JavaScript and what is its use?

Accepted Answer

Currying transforms a function taking multiple arguments into a chain of nested functions, each taking a single argument: `f(a,b,c)` to `f(a)(b)(c)`. It is useful for partial function application, code reuse, and functional composition patterns.

Question 6

Explain how JavaScript memory management works and how garbage collection occurs.

Accepted Answer

JavaScript allocates memory automatically when objects are created and releases it when they are no longer referenced. Garbage collection runs in the background using the Mark-and-Sweep algorithm. It starts at roots (like global scope variables) and marks all reachable objects, deallocating any unmarked elements.

Question 7

How do you trace and fix memory leaks caused by closures?

Accepted Answer

Memory leaks occur when inner functions retain outer scope references that are no longer needed. To fix them, verify that closures do not persist references inside global event listeners or timers, and manually assign variables to `null` once they are no longer needed.

Question 8

Explain how Jest mocks imports and mocks function calls.

Accepted Answer

Jest mocks imports using `jest.mock('./module')` which intercepts module resolutions. You mock functions using `jest.fn()`, which allows you to inspect call frequencies, arguments passed, and customize mock return values for unit isolation.

Question 9

What are JavaScript generators and when are they useful?

Accepted Answer

Generators are functions that can be exited and re-entered, maintaining context across ticks. Declared with `function*`, they use `yield` to output values. They are useful for creating custom iterators and managing asynchronous control flows.

Question 10

What is the difference between Array.prototype.map and Array.prototype.flatMap?

Accepted Answer

`map()` returns a new array where elements are transformed callback values. `flatMap()` applies the callback and then flattens the resulting array by a depth of 1, which is useful when mapping elements to variable-length arrays.

Question 11

How does the JS runtime compile code using JIT compilers?

Accepted Answer

Engines like V8 compile JavaScript using a Just-In-Time (JIT) compiler. It parses code into an AST, interprets it quickly into bytecode, and uses an optimizing compiler to compile frequently run functions ('hot code') into native machine instructions.

Question 12

Explain the difference between event bubbling and capturing.

Accepted Answer

They are two event propagation phases:
- Capturing travels from the document root down to the target element.
- Bubbling (default) travels from the target element back up to the document root.
You configure capturing using `{ capture: true }` in `addEventListener`.

Question 13

What are WeakMap and WeakSet and how do they prevent leaks?

Accepted Answer

WeakMap and WeakSet hold weak references to objects. Unlike standard Map/Set, they do not prevent garbage collection from cleaning up member objects if no other references exist, making them ideal for caching metadata without causing leaks.

Question 14

How do you execute testing suites for asynchronous functions?

Accepted Answer

Test suites use async/await assertions or return promises. If an exception is expected, test assertions should use `.rejects.toThrow()` to verify that asynchronous handlers reject correctly under failing inputs.

Question 15

Explain the design of the standard Pub/Sub pattern in pure JavaScript.

Accepted Answer

A Publisher-Subscriber pattern uses an events broker object. Subscriptions register callbacks to named channels, and publishers emit events to those channels, triggering all registered callbacks without tightly coupling components.

Question 16

What is the difference between deep merging and shallow merging?

Accepted Answer

Shallow merging (`Object.assign` or spread syntax) replaces nested object references entirely. Deep merging iterates through properties recursively, combining attributes of nested objects instead of overwriting them.

Question 17

How do you intercept object actions using Proxy?

Accepted Answer

A `Proxy` wraps an object, letting you intercept actions (like property access, assignment, function invocation) using trap handlers (`get`, `set`), which is useful for validation or reactive state systems.

Question 18

Explain how to write custom errors extending the Error class.

Accepted Answer

Extend the native `Error` class and call `super()`. Set custom properties like `statusCode` or error codes, and capture stack traces using `Error.captureStackTrace` to assist debugging.

Question 19

What is the difference between window.onload and DOMContentLoaded?

Accepted Answer

`DOMContentLoaded` fires once the HTML document structure is fully parsed, without waiting for stylesheets or images. `window.onload` fires later, once the entire page including styling, images, and sub-frames is fully loaded.

Question 20

How do you debug async call stacks in browser devtools?

Accepted Answer

Enable Async Stack Traces in DevTools settings. When execution pauses at a breakpoint inside an asynchronous callback, the call stack panel reconstructs the execution pathway back to its original trigger source.

Question 21

How does JavaScript garbage collection handle memory management, and how do you profile leaks?

Accepted Answer

JavaScript handles memory allocation and cleanup automatically using a garbage collector that runs in the background. The primary algorithm used by modern engines (like Google V8) is Mark-and-Sweep. Starting from reference roots (the global object and stack variables), the engine recursively 'marks' all reachable objects. Once marking completes, the engine sweeps through memory, deallocating any 'unmarked' objects.

Memory leaks occur when references to dead objects are retained in reachable roots, preventing garbage collection. Common causes include:
- Forgotten Event Listeners: Attaching listeners to elements that are deleted without removing the listeners.
- Stale Closures: Inner functions retaining outer variables that are no longer needed.
- Detached DOM Nodes: Storing references to HTML elements in JS arrays after removing them from the screen.

To profile these leaks, open Chrome DevTools, navigate to the Memory tab, and take heap snapshots. Filter by 'detached' to find orphaned HTML nodes, and look for growing memory allocations on the timeline during repeated actions.

Question 22

Explain how V8 optimizations (Hidden Classes and Inline Caches) speed up dynamic property lookups.

Accepted Answer

Since JavaScript is dynamic, properties can be added to objects at runtime. This makes lookup slow. V8 optimizes this using:
1. Hidden Classes (Shapes): V8 creates internal hidden classes mapping property offsets. If two objects share the same structure, they share the hidden class.
2. Inline Caches (IC): V8 remembers the offset of properties from previous lookups. If subsequent lookups match the same hidden class, V8 bypasses search steps and retrieves properties directly.

Question 23

Explain the architecture of distributed tracing and tracing context propagation in async JS.

Accepted Answer

In distributed applications, trace contexts (containing trace IDs and span IDs) must be passed across async boundary calls. In Node, use OpenTelemetry with `AsyncLocalStorage` to store context states. The trace headers are attached to fetch calls, letting tracing tools associate logs across multiple microservices.

Question 24

Explain how to protect JavaScript applications against prototype pollution attacks.

Accepted Answer

Prototype Pollution occurs when user input modifies `__proto__` or `constructor.prototype` properties, injecting parameters onto all objects. Mitigations include:
1. Object Freezing: Call `Object.freeze(Object.prototype)` to block prototype extensions.
2. Null Prototypes: Create safe objects using `Object.create(null)` to bypass prototype chains.
3. Input Validation: Validate incoming JSON objects using strict schemas (e.g. Zod) to filter prototype keys.

Question 25

How would you handle heavy computations in the browser without blocking UI layouts?

Accepted Answer

To run heavy computations in the browser, delegate tasks to Web Workers. Web Workers execute JavaScript in a background thread, preventing blocking on the main thread. Communicate using `postMessage()` and transfer binary objects (like `ArrayBuffer`) using Transferables to avoid copy overhead.

Question 26

How does the V8 garbage collector optimize collection times?

Accepted Answer

V8 uses generational garbage collection. It divides memory into two generations:
1. New Space: Small area where new allocations occur. Collected frequently using a fast Scavenge algorithm.
2. Old Space: Large area where surviving objects are promoted. Collected less frequently using Mark-Sweep-Compact.

Question 27

Explain memory profiling using V8 allocation profiling maps.

Accepted Answer

Allocation profiling maps record allocation stacks in real-time. Start Node with `--heap-prof` to output profile files. Import profiles into Chrome DevTools to locate exactly which constructors and functions are generating excessive heap allocations.

Question 28

What is cross-origin resource sharing (CORS) security and how does it prevent attacks?

Accepted Answer

CORS is a browser security mechanism that restricts web pages from requesting resources from a different domain than the one that served the page. Browsers send a preflight OPTIONS request to verify CORS headers (`Access-Control-Allow-Origin`), preventing unauthorized data reads.

Question 29

How does WebAssembly (Wasm) integrate with JavaScript applications?

Accepted Answer

WebAssembly compiles low-level code (like Rust or C++) into binary modules. JavaScript loads these modules using `WebAssembly.instantiateStreaming()`, exposing high-performance functions that execute at near-native speeds.

Question 30

How do you debug complex Node.js memory leaks using heap dump comparisons?

Accepted Answer

Use the `heapdump` library or Node's inspector interface. Trigger heap snapshots at different times during a load test. Compare these snapshots inside Chrome DevTools using the 'Comparison' view to find which constructors have growing instance counts.

Question 31

Explain microtask starvation and how it occurs in loop tick cycles.

Accepted Answer

Microtask starvation occurs when microtask callbacks (like recursive Promise resolves) continually append new tasks to the microtasks queue. Since the event loop must empty the microtask queue before moving to macrotasks or rendering, the browser freezes and user interactions block.

Question 32

How do you secure third-party scripts from performing XSS on client cookies?

Accepted Answer

Configure all authentication cookies with the `HttpOnly` attribute. This instructs browser engines to block access to these cookies from JavaScript (`document.cookie`), preventing malicious third-party scripts from stealing session tokens.

Question 33

What is tail call optimization and is it supported in JS engines?

Accepted Answer

Tail call optimization (TCO) allows recursive function calls to run without increasing call stack depths if the recursive call is the final statement. While defined in ES6, it is only fully supported by WebKit (Safari), and not by V8 (Chrome/Node).

Question 34

How do you implement client-side encryption using the Web Crypto API?

Accepted Answer

Use the built-in `window.crypto.subtle` API. It supports generating keys, signing payloads, and executing algorithms (like AES-GCM or RSA-OAEP) directly in browser threads, enabling client-side encryption before transmitting data.

Question 35

How do you optimize network downloads using JavaScript compression APIs?

Accepted Answer

Use standard Compression Streams (`CompressionStream` and `DecompressionStream`). These APIs allow streaming data chunks to be compressed or decompressed in real-time inside browser threads, reducing network payloads.

Question 36

Explain the architecture of ES6 proxies inside reactivity engines.

Accepted Answer

Reactivity engines (like Vue 3) wrap state objects in ES6 Proxies. The proxy intercepts access (`get` trap) to track dependencies, and intercepts updates (`set` trap) to trigger UI re-renders and compute updates automatically.

Question 37

How do you debug Node performance bottlenecks using CPU profiling?

Accepted Answer

Start Node with `--cpu-prof`. Run load tests, then import the resulting `.cpuprofile` file into Chrome DevTools Profiler. Use the flame chart to identify functions with high 'Self Time' to locate CPU hotspots.

Question 38

Explain the differences between JavaScript array buffers and typed arrays.

Accepted Answer

An `ArrayBuffer` represents a raw binary data buffer of fixed length. You cannot access or modify its contents directly. Instead, you wrap it in a `TypedArray` (like `Int32Array`) or a `DataView` to read and write bytes.

Question 39

How do you implement a secure Content Security Policy (CSP) in JavaScript apps?

Accepted Answer

Set CSP HTTP headers or meta tags to restrict script origins, block inline scripts, and enforce connection targets. Generate runtime nonces (`nonce-` tags) to authorize dynamic script injections securely.

Question 40

How do you profile JavaScript garbage collection logs?

Accepted Answer

Start the Node runtime with `--trace-gc` or `--trace-gc-verbose`. This prints memory reclamation statistics, execution durations, and sweep details directly to logs, enabling collection efficiency analysis.

Senior JavaScript Interview Questions (5+ Years Experience) (2026)

What is JavaScript and Why is it Critical in Modern Engineering?

JavaScript Lifecycle Visualizer

Core Architectural Concepts in JavaScript

Lexical Scope & Closures

Prototypal Chain

Event Loop Microtasks

Async Promisify Control

V8 Engine Internals

check_circleWhy Modern Companies Choose JavaScript

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Performance