Middle JavaScript Interview Questions (50 MCQs)

Question 1

What is a closure?

Accepted Answer

A function that retains access to outer-scope variables after that scope finishes

Answer

A way to close a browser tab

Answer

Just another name for arrow functions

Answer

A class-only design pattern

Question 2

What does this print? `console.log(1); setTimeout(()=>console.log(2),0); Promise.resolve().then(()=>console.log(3)); console.log(4);`

Accepted Answer

`1 4 3 2`

Answer

`1 2 3 4`

Answer

`1 4 2 3`

Answer

`1 3 4 2`

Question 3

How is `this` determined in an arrow function?

Accepted Answer

It is taken lexically from the outer scope

Answer

It always points to global/window

Answer

It always changes with `call`

Answer

It only exists inside classes

Question 4

What are the states of a Promise?

Accepted Answer

pending / fulfilled / rejected

Answer

open / closed / aborted

Answer

start / middle / end

Answer

loading / success only

Question 5

In `const { a, ...rest } = obj`, what does `...rest` do?

Accepted Answer

Collects remaining properties into an object

Answer

Reverses an array

Answer

Only works with classes

Answer

Deletes the whole object

Question 6

What happens when a property is missing on an object?

Accepted Answer

The engine walks the prototype chain until `null`

Answer

A TypeError is always thrown

Answer

Immediately `undefined` with no lookup

Answer

It only happens in ESM

Question 7

What are `0 ?? 5` and `0 || 5`?

Accepted Answer

`0` and `5`

Answer

`5` and `5`

Answer

`0` and `0`

Answer

`5` and `0`

Question 8

How does `bind` differ from `call`/`apply`?

Accepted Answer

`bind` returns a new function with fixed `this` without calling it

Answer

`bind` calls the function immediately

Answer

`bind` only works on arrow functions

Answer

There is no difference

Question 9

Which can be called before its definition?

Accepted Answer

`function foo() {}` (function declaration)

Answer

`const foo = () => {}`

Answer

`let foo = function () {}`

Answer

`class Foo {}`

Question 10

If one promise rejects, what does `Promise.all` do?

Accepted Answer

Rejects immediately with that error

Answer

Waits for all and returns the successful ones

Answer

Ignores the error

Answer

Retries the promise

Question 11

What kind of copy is `const b = { ...a }`?

Accepted Answer

Shallow: nested objects stay shared

Answer

Deep: every level is copied

Answer

Just the same reference

Answer

Only method properties

Question 12

What is event delegation?

Accepted Answer

One listener on a parent, detecting the target via `event.target`

Answer

Attaching a listener to every child

Answer

Blocking all events

Answer

Running events in a Web Worker

Question 13

What does `for (var i = 0; i < 3; i++) setTimeout(() => console.log(i));` print?

Accepted Answer

`3 3 3`

Answer

`0 1 2`

Answer

`2 2 2`

Answer

`undefined` three times

Question 14

What does `async function a() { console.log(1); await null; console.log(2); } a(); console.log(3);` print?

Accepted Answer

`1 3 2`

Answer

`1 2 3`

Answer

`3 1 2`

Answer

`1 3`, and `2` never prints

Question 15

What does `Promise.allSettled([Promise.resolve(1), Promise.reject('e')])` resolve to?

Accepted Answer

`[{ status: 'fulfilled', value: 1 }, { status: 'rejected', reason: 'e' }]`

Answer

It rejects with `'e'`

Answer

`[1, 'e']`

Answer

`[1]`

Question 16

How does `Promise.any` differ from `Promise.race`?

Accepted Answer

`any` takes the first fulfillment ignoring rejections; `race` settles with the first to settle either way

Answer

`race` takes the first fulfillment ignoring rejections; `any` settles with the first to settle

Answer

Both wait for all promises to finish

Answer

No difference; `any` is just a new name for `race`

Question 17

Given `async function f() { return 1; }`, what is `f()`?

Accepted Answer

A Promise that resolves to `1`

Answer

The number `1`

Answer

`undefined`

Answer

A generator object

Question 18

Why does `ids.forEach(async id => { await save(id); }); console.log('done');` log `done` before saves finish?

Accepted Answer

`forEach` doesn't wait for promises returned by the callback

Answer

`await` doesn't work inside callbacks and throws

Answer

`forEach` runs callbacks in a Web Worker

Answer

`console.log` always runs before everything

Question 19

If independent `getA` and `getB` each take 1s, roughly how long does `const a = await getA(); const b = await getB();` take?

Accepted Answer

About 2s, because they run sequentially

Answer

About 1s, they're parallelized automatically

Answer

Near zero, since `await` is non-blocking

Answer

About 0.5s

Question 20

In `async function f() { try { return fetchData(); } catch (e) { return 'fallback'; } }`, what happens if `fetchData` rejects?

Accepted Answer

`catch` doesn't run and `f`'s promise rejects

Answer

`catch` runs and returns `'fallback'`

Answer

A syntax error occurs

Answer

The function stays pending forever

Question 21

What happens with `console.log(x); let x = 1;`?

Accepted Answer

A `ReferenceError`

Answer

`undefined`

Answer

`1`

Answer

`null`

Question 22

What happens with `class A { n = 'a'; get() { return this.n; } } const g = new A().get; g();`?

Accepted Answer

A `TypeError` because `this` is `undefined`

Answer

`'a'`

Answer

`undefined`

Answer

`window.n`

Question 23

`parent` has a listener with `{ capture: true }` and `child` a normal one. Clicking `child`, which runs first?

Accepted Answer

The parent's listener

Answer

The child's listener

Answer

Only the child's runs

Answer

It depends on the browser

Question 24

After `Object.defineProperty(o, 'x', { value: 1 })`, does `Object.keys(o)` include `x`?

Accepted Answer

No; `enumerable`, `writable`, `configurable` default to `false`

Answer

Yes; all flags default to `true`

Answer

Yes, but it's read-only

Answer

It throws because no `get` was given

Question 25

Which is an advantage of `Map` over a plain object?

Accepted Answer

Any value (even objects) can be a key, and it has `size`

Answer

It serializes automatically with `JSON.stringify`

Answer

It keeps keys sorted alphabetically

Answer

It frees memory automatically like `WeakMap`

Question 26

What does `[...new Set([1, '1', 1, NaN, NaN])]` return?

Accepted Answer

`[1, '1', NaN]`

Answer

`[1, NaN]`

Answer

`[1, '1', NaN, NaN]`

Answer

`[1]`

Question 27

With `const make = () => { let c = 0; return () => ++c; };`, what does `const a = make(); a(); a(); const b = make(); console.log(b());` print?

Accepted Answer

`1`

Answer

`3`

Answer

`2`

Answer

`0`

Question 28

What does `function P() { this.a = 1; return { b: 2 }; } console.log(new P().a);` print?

Accepted Answer

`undefined`

Answer

`1`

Answer

`2`

Answer

A `TypeError`

Question 29

Given `class C { #secret = 1; }`, what happens with `new C().#secret` outside the class?

Accepted Answer

A `SyntaxError` at parse time

Answer

Returns `undefined`

Answer

Returns `1`

Answer

Throws only in strict mode

Question 30

With `class B extends A { constructor() { this.x = 1; super(); } }`, what happens on `new B()`?

Accepted Answer

A `ReferenceError` because `this` is used before `super()`

Answer

It runs fine

Answer

`x` is silently ignored

Answer

`super()` is automatically hoisted to run first

Question 31

What exactly does `obj instanceof Foo` check?

Accepted Answer

Whether `Foo.prototype` appears in `obj`'s prototype chain

Answer

Whether `obj.constructor === Foo`

Answer

Whether `obj` has all of `Foo`'s properties

Answer

Whether `typeof obj === 'Foo'`

Question 32

What is special about an object made with `Object.create(null)`?

Accepted Answer

It has no prototype, so no inherited `toString` or `hasOwnProperty`

Answer

It equals `null`

Answer

It's immutable

Answer

It's identical to `{}`

Question 33

What does `[1, [2, [3, [4]]]].flat()` return?

Accepted Answer

`[1, 2, [3, [4]]]`

Answer

`[1, 2, 3, 4]`

Answer

`[1, [2, [3, [4]]]]`

Answer

`[1, 2, 3, [4]]`

Question 34

What happens if the server answers `fetch(url)` with `404`?

Accepted Answer

The promise resolves with a `Response` whose `ok` is `false`

Answer

The promise rejects with a `TypeError`

Answer

`fetch` retries automatically

Answer

The promise stays pending forever

Question 35

What is the type of `JSON.parse(JSON.stringify({ d: new Date() })).d`?

Accepted Answer

A string (ISO format)

Answer

A `Date` object

Answer

A numeric timestamp

Answer

`null`

Question 36

What are `isNaN('abc')` and `Number.isNaN('abc')`?

Accepted Answer

`true` and `false`

Answer

`true` and `true`

Answer

`false` and `false`

Answer

`false` and `true`

Question 37

How does `arr.sort()` differ from `arr.toSorted()`?

Accepted Answer

`sort` mutates in place; `toSorted` returns a new array

Answer

`toSorted` mutates; `sort` returns a copy

Answer

`toSorted` only sorts numbers

Answer

There is no difference

Question 38

What is `cause` for in `new Error('Save failed', { cause: err })`?

Accepted Answer

Chaining errors while preserving the original for debugging

Answer

Preventing the error from being thrown

Answer

Automatically reporting the error to a server

Answer

Setting an HTTP status code

Question 39

Why is `requestAnimationFrame` better than `setInterval` for JS animations?

Accepted Answer

It syncs with the browser's paint cycle and pauses in hidden tabs

Answer

It always runs exactly 120 times per second

Answer

It runs the callback in a Web Worker

Answer

It uses the GPU to execute JavaScript

Question 40

Which API is best for lazy-loading images as they enter the viewport?

Accepted Answer

`IntersectionObserver`

Answer

A `scroll` listener calling `getBoundingClientRect` each event

Answer

`MutationObserver`

Answer

`setInterval` polling positions

Question 41

What does `{ passive: true }` in `addEventListener('touchstart', fn, { passive: true })` do?

Accepted Answer

Promises `preventDefault` won't be called, so scrolling needn't wait

Answer

Runs the listener only once

Answer

Runs the listener in the capture phase

Answer

Stops the event from propagating

Question 42

How do you send data with a custom DOM event?

Accepted Answer

`el.dispatchEvent(new CustomEvent('saved', { detail: data }))`

Answer

`el.emit('saved', data)`

Answer

`el.trigger('saved', data)`

Answer

`new Event('saved', data)` and read `e.data`

Question 43

What are `[10, 20, 30].at(-1)` and `[10, 20, 30][-1]`?

Accepted Answer

`30` and `undefined`

Answer

`30` and `30`

Answer

`undefined` and `30`

Answer

`10` and `undefined`

Question 44

What does `Object.fromEntries(Object.entries({ a: 1, b: 2 }).map(([k, v]) => [k, v * 10]))` return?

Accepted Answer

`{ a: 10, b: 20 }`

Answer

`[['a', 10], ['b', 20]]`

Answer

`{ a: 1, b: 2 }`

Answer

`[10, 20]`

Question 45

What is `for await (const chunk of stream)` used for?

Accepted Answer

Iterating async iterables, awaiting each value in order

Answer

Running all iterations in parallel

Answer

Moving the loop into a Web Worker

Answer

Only for plain arrays; it doesn't work on streams

Question 46

What are `Symbol('id') === Symbol('id')` and `Symbol.for('id') === Symbol.for('id')`?

Accepted Answer

`false` and `true`

Answer

`true` and `true`

Answer

`false` and `false`

Answer

`true` and `false`

Question 47

After `const a = [1, 2, 3]; delete a[1];`, what are `a.length` and `1 in a`?

Accepted Answer

`3` and `false`

Answer

`2` and `false`

Answer

`3` and `true`

Answer

`2` and `true`

Question 48

What does `'a-b-c'.replace('-', '+')` return?

Accepted Answer

`'a+b-c'`

Answer

`'a+b+c'`

Answer

`'a-b+c'`

Answer

`'a-b-c'`

Question 49

Given `class U { constructor(f, l) { this.f = f; this.l = l; } get full() { return this.f + ' ' + this.l; } }`, how do you read the full name?

Accepted Answer

`u.full` (no parentheses)

Answer

`u.full()`

Answer

`u.get('full')`

Answer

`U.full(u)`

Question 50

What is the main purpose of an IIFE like `(function () { /* ... */ })();`?

Accepted Answer

Creating a private scope and avoiding global pollution

Answer

Running the function asynchronously

Answer

Defining a function to call many times later

Answer

Making code run faster

JavaScript · Middle · 50

What is a closure?