JavaScript Interview Questions

Scope, hoisting and reassignment.

var is function-scoped and hoisted as undefined. let and const are block-scoped and throw a ReferenceError if used before their declaration (the temporal dead zone). const cannot be reassigned, though objects it holds can still be modified. Use const by default, let when the value changes.

One converts types first.

=== compares type and value without conversion; == converts types first:

console.log(0 == "", 0 === "", null == undefined, null === undefined);

true false true false

Use === (and value == null only as a deliberate check for both null and undefined).

There are eight.

false, 0, -0, 0n, "", null, undefined and NaN. Everything else is truthy, including "0", [] and {}.

A function that remembers variables from where it was created.

A closure is a function together with the variables of the scope it was created in, which it keeps using after that scope has finished:

function counter() {
  let count = 0;
  return () => ++count;
}
const next = counter();
next();
console.log(next());

2

Closures give private state, function factories and callbacks that remember context.

How many variables called i are there?

const fns = [];
for (var i = 0; i < 3; i++) fns.push(() => i);
console.log(fns.map((f) => f()));

[ 3, 3, 3 ]

var creates one shared i, which is 3 when the functions run. With let, each iteration gets its own binding and the result is [ 0, 1, 2 ].

It depends on how the function is called.

obj.method() sets this to obj; a plain call fn() gives undefined in strict mode; new Fn() gives the new object; call, apply and bind set it explicitly; arrow functions have no own this and use the surrounding one.

Synchronous code, then microtasks, then tasks.

console.log("A");
setTimeout(() => console.log("B"), 0);
Promise.resolve().then(() => console.log("C"));
console.log("D");

A
D
C
B

Promise callbacks are microtasks and run before the next timer task.

When does each one resolve or reject?

all resolves with every value when all fulfil and rejects on the first rejection. allSettled waits for all and reports each status. race settles with the first promise to settle. any resolves with the first fulfilment and rejects only if all reject.

A rejected promise throws at await.

Wrap await calls in try...catch (with finally for cleanup). A rejected promise throws at the await. For independent operations, use await Promise.all([...]) or Promise.allSettled to handle several results. Remember that fetch does not reject on HTTP errors, so check response.ok.

Events bubble.

Instead of a listener on every child, put one listener on a parent and use event.target.closest(selector) to find which child was involved. It works because events bubble up, handles elements added later, and uses fewer listeners.

What happens to nested objects?

const original = { tags: ["js"] };
const shallow = { ...original };
const deep = structuredClone(original);
shallow.tags.push("css");
console.log(original.tags, deep.tags);

[ 'js', 'css' ] [ 'js' ]

Spread copies only the top level; nested objects are shared. structuredClone copies everything.

Clear the previous timer on every call.

function debounce(fn, ms) {
  let timer;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), ms);
  };
}

const log = debounce((q) => console.log("search", q), 30);
log("j");
log("js");

search js

Only the last call within the wait time runs, which is ideal for search-as-you-type.

Where does array.push come from?

Every object links to a prototype. When a property is missing on the object, JavaScript looks it up the chain (array → Array.prototype → Object.prototype → null). Shared methods live on prototypes. Classes are syntax over this mechanism: methods go on Class.prototype, and extends links prototypes.

Remember the numbers you have already seen.

function twoSum(nums, target) {
  const seen = new Map();
  for (let i = 0; i < nums.length; i++) {
    if (seen.has(target - nums[i])) return [seen.get(target - nums[i]), i];
    seen.set(nums[i], i);
  }
  return null;
}
console.log(twoSum([2, 7, 11, 15], 9));

[ 0, 1 ]

A Map gives O(n) time instead of the O(n²) nested-loop solution.