Senior JavaScript Interview Questions (50 MCQs)

Question 1

Which can cause a frontend memory leak?

Accepted Answer

A window listener never removed

Answer

Using `const` instead of `let`

Answer

Writing TypeScript

Answer

Using template literals

Question 2

For limiting function runs while typing in a search box, which fits better?

Accepted Answer

Debounce

Answer

Throttle

Answer

Only `setInterval`

Answer

`Object.freeze`

Question 3

What does a `function*` return?

Accepted Answer

A Generator/Iterator that can pause via `yield`

Answer

Always a Promise

Answer

A Proxy

Answer

Nothing

Question 4

What restriction do WeakMap keys have?

Accepted Answer

Keys must be objects

Answer

Only strings

Answer

Only numbers

Answer

No restriction, same as Map

Question 5

Which trait is more characteristic of ESM than CommonJS?

Accepted Answer

Static, tree-shakeable `import`/`export`

Answer

Mandatory use of `require`

Answer

Always fully synchronous loading in browsers

Answer

No support in modern browsers

Question 6

What is Proxy mainly used for?

Accepted Answer

Intercepting fundamental object ops like get/set

Answer

Image compression

Answer

A full HTTP replacement

Answer

Only for unit tests

Question 7

Advantage of `structuredClone` over `JSON.parse(JSON.stringify(x))`?

Accepted Answer

Supports `Date`, `Map`, `Set`, and circular references

Answer

It also copies functions

Answer

It only makes shallow copies

Answer

It only works in Node

Question 8

What happens if microtasks keep scheduling new microtasks?

Accepted Answer

Rendering and macrotasks are starved

Answer

The browser moves them to setTimeout

Answer

Only the first one runs

Answer

Nothing happens

Question 9

What is used to cancel an in-flight `fetch`?

Accepted Answer

`AbortController` and its `signal`

Answer

`clearTimeout`

Answer

`Promise.cancel()`

Answer

`fetch.stop()`

Question 10

Which is true about Web Workers?

Accepted Answer

Runs heavy work off the main thread but has no DOM access

Answer

Directly manipulates the DOM

Answer

Shares synchronous state with the main thread

Answer

Only for CSS animations

Question 11

What does `Object.freeze` do to nested objects?

Accepted Answer

Only the top level is frozen (shallow)

Answer

Every level is deeply frozen

Answer

It deletes the object

Answer

It only freezes methods

Question 12

How do you make a custom object work with `for...of`?

Accepted Answer

Implement `[Symbol.iterator]()`

Answer

Add a `length` property

Answer

Inherit from `Array` only

Answer

Define a `forEach` method

Question 13

Why can creating objects as `{ x, y }` in one place and `{ y, x }` elsewhere, then passing both to a hot function, be slow?

Accepted Answer

Different property order yields different hidden classes, making inline caches polymorphic

Answer

The engine spawns a thread per object

Answer

Objects with different orders are always stored in dictionary mode

Answer

Order has no effect; only the property count matters

Question 14

Performance-wise in V8, what's the issue with `const a = new Array(1000)` then filling it gradually?

Accepted Answer

It starts with a HOLEY elements kind and never transitions back to PACKED

Answer

The array is stored on disk until full

Answer

Every assignment copies the entire array

Answer

No issue; it's always the fastest approach

Question 15

In `function f() { const big = new Array(1e6).fill(0); const unused = () => big.length; return () => 1; }`, does the returned function keep `big` alive?

Accepted Answer

Yes; closures in one scope share a context that includes `big`

Answer

No; the returned function doesn't use `big`

Answer

No; `const` is always freed after return

Answer

Only in strict mode

Question 16

What does `setTimeout(() => log(1)); Promise.resolve().then(() => { log(2); setTimeout(() => log(3)); }); queueMicrotask(() => log(4)); log(5);` print?

Accepted Answer

`5 2 4 1 3`

Answer

`5 4 2 1 3`

Answer

`5 2 4 3 1`

Answer

`5 1 2 4 3`

Question 17

With `const p = Promise.resolve(1);`, what are `Promise.resolve(p) === p` and `new Promise(r => r(p)) === p`?

Accepted Answer

`true` and `false`

Answer

`false` and `false`

Answer

`true` and `true`

Answer

`false` and `true`

Question 18

If a promise rejects and its handler is attached later (e.g. in a `setTimeout`), what happens in the browser?

Accepted Answer

`unhandledrejection` fires first, then `rejectionhandled` once a handler is attached

Answer

The late handler never runs

Answer

The browser reloads the page

Answer

No event fires because it was eventually handled

Question 19

Which is true about `WeakRef` and `FinalizationRegistry`?

Accepted Answer

Cleanup callbacks aren't guaranteed to run; critical logic mustn't depend on them

Answer

The callback runs immediately after the last reference is dropped

Answer

`deref()` always returns the object

Answer

`WeakRef` protects the object from GC forever

Question 20

Why is `for (const el of items) { el.style.width = box.offsetWidth + 'px'; }` slow?

Accepted Answer

Reading `offsetWidth` after each write forces a synchronous reflow

Answer

`style.width` only works inside `requestIdleCallback`

Answer

`for...of` over a NodeList is always slow

Answer

Concatenating `'px'` uses a lot of memory

Question 21

After `worker.postMessage(buf, [buf])` where `buf` is an `ArrayBuffer`, what is `buf.byteLength` on the main thread?

Accepted Answer

`0`, because ownership was transferred and the buffer is detached

Answer

The original size, since it was copied

Answer

`undefined`

Answer

A `DataCloneError`

Question 22

What is required to use `SharedArrayBuffer` in modern browsers?

Accepted Answer

Cross-origin isolation via `COOP: same-origin` and `COEP: require-corp` headers

Answer

Only running on `localhost`

Answer

Enabling strict mode in all scripts

Answer

Registering a Service Worker

Question 23

With `const t = Object.freeze({ a: 1 }); const p = new Proxy(t, { get: () => 2 });`, what does reading `p.a` do?

Accepted Answer

Throws a `TypeError` for violating a proxy invariant

Answer

Returns `2`

Answer

Returns `1`, ignoring the trap

Answer

Returns `undefined`

Question 24

Why return `Reflect.get(target, key, receiver)` rather than `target[key]` in a `get(target, key, receiver)` trap?

Accepted Answer

So getters run with `this` as the proxy, routing inner accesses through the trap

Answer

Because `target[key]` is a syntax error in a Proxy

Answer

`Reflect.get` caches results

Answer

`Reflect.get` also returns private fields

Question 25

What are `0 === -0`, `Object.is(0, -0)`, and `1 / -0`?

Accepted Answer

`true`, `false`, `-Infinity`

Answer

`true`, `true`, `Infinity`

Answer

`false`, `false`, `-Infinity`

Answer

`true`, `false`, `NaN`

Question 26

What is `2 ** 53 === 2 ** 53 + 1`?

Accepted Answer

`true`

Answer

`false`

Answer

`NaN`

Answer

A `RangeError`

Question 27

What do `1n + 1` and `JSON.stringify({ id: 1n })` do?

Accepted Answer

Both throw a `TypeError`

Answer

`2n` and `'{"id":1}'`

Answer

`2` and `'{"id":"1n"}'`

Answer

`2n` and `'{}'`

Question 28

A naive deep merge merges `JSON.parse('{"__proto__": {"isAdmin": true}}')` into `{}`. What is `({}).isAdmin` afterwards?

Accepted Answer

`true`, because `Object.prototype` got polluted

Answer

`undefined`, because `JSON.parse` drops `__proto__`

Answer

`false`

Answer

The merge throws a `TypeError`

Question 29

In `counter.js`: `export let count = 0; export const inc = () => count++;` and in `main.js`: `import { count, inc } from './counter.js'; inc(); console.log(count);`: what's printed?

Accepted Answer

`1`, because ESM imports are live bindings

Answer

`0`, because the value was copied at import time

Answer

A `TypeError` because imports are read-only

Answer

`undefined`

Question 30

`a.js` imports `b.js`, and `b.js` uses `a.js`'s `export const x` at top level. If `a.js` is the entry, what happens?

Accepted Answer

A `ReferenceError` because `x` is still in the TDZ

Answer

`b.js` sees `undefined`

Answer

The engine reorders evaluation automatically

Answer

Module loading loops forever

Question 31

What effect does top-level `await` in an ES module have on modules importing it?

Accepted Answer

Dependent modules' evaluation is delayed until it resolves

Answer

The browser's main thread is fully blocked

Answer

Importers get `undefined` and continue

Answer

It's only allowed in CommonJS

Question 32

Why do schedulers like React's use `MessageChannel` instead of repeated `setTimeout(fn, 0)`?

Accepted Answer

Nested `setTimeout`s get clamped to at least 4ms after a few levels

Answer

`MessageChannel` runs callbacks as microtasks

Answer

`setTimeout` is disabled inside React

Answer

`MessageChannel` runs code on a separate thread

Question 33

When does `setTimeout(fn, 2 ** 31)` (about 25 days) fire?

Accepted Answer

Almost immediately, since the delay overflows a signed 32-bit int

Answer

Exactly after 25 days

Answer

It never fires

Answer

It throws a `RangeError`

Question 34

With `function* g() { try { yield 1; yield 2; } finally { console.log('cleanup'); } }`, what happens if `for (const x of g()) { break; }` exits early?

Accepted Answer

`for...of` calls `return()`, so `cleanup` is logged

Answer

The generator stays suspended and `finally` never runs

Answer

`break` throws on a generator loop

Answer

`yield 2` runs, then `cleanup`

Question 35

Which guarantee was added to `Array.prototype.sort` in ES2019?

Accepted Answer

It is stable; equal elements keep their relative order

Answer

It always runs in O(n)

Answer

It no longer mutates the array

Answer

It sorts numbers numerically by default

Question 36

What are `'😀'.length` and `[...'😀'].length`?

Accepted Answer

`2` and `1`

Answer

`1` and `1`

Answer

`2` and `2`

Answer

`4` and `1`

Question 37

What is `((a, b = 1, c) => {}).length`?

Accepted Answer

`1`

Answer

`3`

Answer

`2`

Answer

`0`

Question 38

What does `new.target` indicate inside a function?

Accepted Answer

The constructor invoked with `new`, or `undefined` if called without `new`

Answer

The newly created `this` object

Answer

The parent prototype

Answer

The last object created with `new`

Question 39

What does `Object.keys({ b: 1, 2: 1, a: 1, 1: 1 })` return?

Accepted Answer

`['1', '2', 'b', 'a']`

Answer

`['b', '2', 'a', '1']`

Answer

`['a', 'b', '1', '2']`

Answer

The order isn't guaranteed

Question 40

What is `[] == ![]`?

Accepted Answer

`true`

Answer

`false`

Answer

A `TypeError`

Answer

`undefined`

Question 41

What does `Array(3).map((_, i) => i)` return?

Accepted Answer

An array with 3 holes (`[ <3 empty items> ]`)

Answer

`[0, 1, 2]`

Answer

`[undefined, undefined, undefined]`

Answer

`[]`

Question 42

How does V8's garbage collector cheaply reclaim most short-lived objects?

Accepted Answer

Generational GC: a copying scavenger for the young generation, mark-sweep-compact for old

Answer

Pure reference counting that also collects cycles

Answer

It only frees memory when the tab closes

Answer

It frees each object right after it leaves scope

Question 43

`add(a, b)` was called thousands of times with numbers and optimized by TurboFan. What happens when it's suddenly called with strings?

Accepted Answer

It deoptimizes and falls back to interpreter bytecode

Answer

It throws a `TypeError` because it was compiled for numbers

Answer

Strings are coerced to numbers automatically

Answer

Nothing; optimized code handles all types equally

Question 44

Given `class C { #n = 0; inc() { this.#n++; return this.#n; } } const c = Object.freeze(new C());`, what does `c.inc()` return?

Accepted Answer

`1`, because `Object.freeze` doesn't affect private fields

Answer

A `TypeError` because the object is frozen

Answer

`0`, since the change is silently ignored

Answer

`NaN`

Question 45

To improve INP while processing a huge array on the main thread, what's the best approach?

Accepted Answer

Chunk the work and yield between chunks with `scheduler.yield()` or `setTimeout`

Answer

Wrap everything in one `Promise.then` to make it async

Answer

Split the work across `queueMicrotask` calls

Answer

Use `for` instead of `forEach`

Question 46

Which is true about `requestIdleCallback`?

Accepted Answer

It runs in idle periods; limit work using `deadline.timeRemaining()`

Answer

It guarantees the callback runs next frame

Answer

It's the best choice for DOM changes and animations

Answer

It runs the callback at the highest priority

Question 47

Why does a direct `eval(code)` inside a function hinder engine optimizations?

Accepted Answer

The code may access any local, so the engine must keep the entire scope alive and unoptimized

Answer

`eval` always runs in a Web Worker

Answer

`eval` is only slow in strict mode

Answer

`eval` downloads code twice

Question 48

What is the final state of `new Promise((res) => { res(1); throw new Error('x'); })`?

Accepted Answer

Fulfilled with `1`; the error is silently ignored

Answer

Rejected with `Error('x')`

Answer

Uncaught error logged; promise stays pending

Answer

Fulfilled first, then switches to rejected

Question 49

What does `console.log(await { then(r) { r(42); } })` print in an ES module?

Accepted Answer

`42`

Answer

The `{ then }` object itself

Answer

`undefined`

Answer

A `TypeError` because it isn't a Promise

Question 50

If an ES module is imported from several places (static and dynamic `import()`) with the same URL, how many times does its top-level code run?

Accepted Answer

Once; the module instance is cached in the module map

Answer

Once per import

Answer

Once for static and once per `import()`

Answer

Every time an export is read

JavaScript · Senior · 50

Which can cause a frontend memory leak?