JavaScript puzzles interview questions and answers

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

It prints 3 3 3. var is function-scoped, so all three callbacks share one i, which is 3 by the time the timers run. With let, each iteration gets its own binding and it prints 0 1 2.

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

A D C B. Synchronous code runs first (A, D). Then the microtask queue: the promise callback (C). Then the timer macrotask (B).

console.log(a);
var a = 1;
console.log(b);
let b = 2;

undefined then a ReferenceError for b. var a is hoisted and initialised to undefined. let b is hoisted but in the temporal dead zone until its declaration runs, so reading it throws.

const arr = [10, 1, 21, 2];
console.log(arr.sort());

It prints [1, 10, 2, 21]. Without a compare function, sort converts numbers to strings and sorts them by UTF-16 code units, so '10' comes before '2'. Use arr.sort((a, b) => a - b) (or toSorted) for numeric order: [1, 2, 10, 21].

async function run() {
  console.log(1);
  setTimeout(() => console.log(2));
  await null;
  console.log(3);
}
run();
console.log(4);

1 4 3 2. The synchronous logs run first (1, 4). await null schedules the rest of the async function as a microtask, which runs before the timer macrotask, so 3 comes before 2.

function makeCounter() {
  let count = 0;
  return () => ++count;
}
const a = makeCounter();
const b = makeCounter();
console.log(a(), a(), b());

1 2 1. Each call to makeCounter creates a new closure with its own count. a is called twice (1, 2); b has a separate count and starts at 1.

const user = {
  name: 'Asha',
  getName() { return this?.name; }
};
const getName = user.getName;
console.log(getName());

undefined. getName is called without an object, so this is undefined in a module or strict mode (or the global object in sloppy scripts, where name may be empty). Methods lose their this when detached; use bind or an arrow wrapper.

console.log(['1', '2', '3'].map(parseInt));

It prints [1, NaN, NaN]. map passes (value, index), so parseInt('1', 0) is 1 (radix 0 means default), parseInt('2', 1) is NaN (radix 1 is invalid) and parseInt('3', 2) is NaN (3 is not a binary digit).

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

2. The closure keeps the count variable alive between calls; each call increments the same variable, and the second call logs 2.

console.log([] == false);
console.log(null == 0);
console.log(NaN !== NaN);

true, false, true. [] == false converts both sides to numbers (0 == 0). null == 0 is false because null only loosely equals undefined. NaN !== NaN is true because NaN is not equal to anything, itself included; use Number.isNaN.

async function run() {
  console.log(1);
  await null;
  console.log(2);
}
run();
console.log(3);

1 3 2. The async function runs synchronously until the first await, logging 1. await yields, so 3 logs next, and 2 logs when the awaited promise resolves in a microtask.

var foo = 1;
function bar() {
  console.log(foo);
  var foo = 2;
}
bar();

undefined. Inside bar, var foo is hoisted to the top of the function and shadows the outer foo, but its assignment has not run yet when it is logged. Hoisting works per function scope.

const a = {};
const b = { key: 'b' };
const c = { key: 'c' };
a[b] = 123;
a[c] = 456;
console.log(a[b]);

It prints 456. Object keys are strings, so both b and c objects are converted to the same key '[object Object]'. The second assignment overwrites the first. Use a Map to key by object identity.

function f() {
  try {
    return 1;
  } finally {
    return 2;
  }
}
console.log(f());

2. finally runs after try even when try returns, and a return inside finally overrides the earlier return value. Avoid returning from finally.

const user = {
  name: 'Asha',
  arrow: () => this?.name,
  regular() { return this.name; }
};
console.log(user.arrow(), user.regular());

undefined then 'Asha'. The arrow function takes this from the surrounding scope (the module, where this is undefined), not from user. The regular method gets this from the call user.regular().

const nums = [1, 2, 3];
console.log(nums);
const copy = nums;
copy.push(4);
console.log(nums, copy);

[ 1, 2, 3 ] and then [ 1, 2, 3, 4 ] for both. const prevents reassigning the variable, not changing the array. copy points to the same array, so pushing through it changes nums too.

console.log('1' == 1, '1' === 1);

true false. == coerces: '1' == 1 compares as numbers. === checks type and value without coercion, so a string and a number are never strictly equal.

console.log({ a: 1 } === { a: 1 });

Objects are compared by reference, not content. The two literals are different objects in memory. Compare specific fields, or use a deep-equal function.

console.log('1' + 2);
console.log('1' - 2);

'12' then -1. With +, if either side is a string the other is converted and concatenated. Other arithmetic operators convert strings to numbers, so '1' - 2 is -1.

const a = [1, 2, 3];
const b = a;
b.push(4);
console.log(a, b);

[1, 2, 3, 4] for both. Arrays are objects held by reference; b points at the same array as a, so pushing through b changes a. Copy with [...a] to avoid it.

console.log(typeof foo);
var foo = 1;
function foo() {}

function. Function declarations are hoisted completely, including their body, and take precedence over the var declaration of the same name until the assignment line runs.

const x = (1, 2, 3);
console.log(x);

3. The comma operator evaluates each expression left to right and returns the last one.

console.log(['1', '7', '11'].map(parseInt));

[ 1, NaN, 3 ]. map passes (value, index), so parseInt receives the index as the radix: '1' with radix 0 (auto) is 1, '7' with radix 1 is invalid (NaN), and '11' in base 2 is 3. Use map(Number) or map(s => parseInt(s, 10)).

const arr = [1, 2, 3];
delete arr[1];
console.log(arr, arr.length);

[ 1, <1 empty item>, 3 ] and length 3. delete removes the property but leaves a hole; the length does not change. Use splice to remove items.

console.log(NaN === NaN, Object.is(NaN, NaN));

false true. NaN is not equal to anything, including itself. Number.isNaN and Object.is(NaN, NaN) detect it correctly.

function f(a, b = a * 2) {
  return b;
}
console.log(f(1));

2. Default parameters are evaluated at call time and can use earlier parameters, so b becomes a * 2 = 2 when only a is passed.

(function () {
  let a = b = 5;
})();
console.log(typeof a, typeof b);

undefined number. In let a = b = 5, b = 5 creates an implicit global (in sloppy mode), and a is block-scoped inside the IIFE. Outside, a is undefined but b exists.

[1, 10, 3]. Without a compare function, sort converts items to strings and compares them by UTF-16 order, so '10' comes before '3'. Use sort((a, b) => a - b) for numbers.

0.30000000000000004. Numbers are IEEE 754 binary floating point, which cannot represent 0.1 and 0.2 exactly. Compare with a tolerance (Math.abs(a - b) < Number.EPSILON) or use integers for money.

console.log(typeof []);

'object'. Arrays are objects in JavaScript; typeof cannot distinguish them. Use Array.isArray.

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i));
}

1. A0 1 2Correct answer
2. B3 3 3
3. Cundefined ×3
4. DError

Why: let creates a new binding per iteration.

console.log(1);
setTimeout(() => console.log(2));
Promise.resolve().then(() => console.log(3));
console.log(4);

1. A1 2 3 4
2. B1 4 3 2Correct answer
3. C1 3 4 2
4. D4 3 2 1

Why: Sync (1, 4), then microtask (3), then timer (2).

1. A"NaN"
2. B"number"Correct answer
3. C"undefined"
4. D"object"

Why: NaN is a special numeric value.

for (let i = 1; i <= 3; i++) {
  setTimeout(() => console.log(i));
}

1. A0 1 2
2. Bundefined
3. C1 2 3Correct answer
4. D3 3 3

Why: let creates a fresh binding per iteration.

setTimeout(() => console.log('macro'));
queueMicrotask(() => console.log('micro'));
console.log('sync');

1. Async, micro, macroCorrect answer
2. Bmacro, micro, sync
3. Cmicro, sync, macro
4. Dsync, macro, micro

Why: Sync code, then microtasks, then timers.

(() => { try { return 1; } finally { return 2; } })()

1. AError
2. B2Correct answer
3. C1
4. Dundefined

Why: A return in finally overrides the try return.

1. ANaN
2. B"[object Object]"Correct answer
3. C0
4. D{}

Why: Both convert to strings: '' + '[object Object]'.

console.log(x);
const x = 5;

1. AReferenceErrorCorrect answer
2. Bnull
3. C5
4. Dundefined

Why: x is in the temporal dead zone before its declaration.

1. ANaN
2. B"baaa"
3. C"banana"
4. D"baNaNa"Correct answer

Why: +'a' is NaN, concatenated as a string.

let x = 1;
const f = () => x;
x = 2;
console.log(f());

1. A2Correct answer
2. B1
3. Cundefined
4. DError

Why: The closure shares x, which changed before the call.

1. Afalse, trueCorrect answer
2. Bfalse, false
3. Ctrue, true
4. Dtrue, false

Why: includes uses SameValueZero, which matches NaN.

console.log((1, 2, 3));

1. A[1, 2, 3]
2. Bundefined
3. C3Correct answer
4. D1

Why: The comma operator returns the last value.

1. A'hello'
2. Bundefined
3. C5Correct answer
4. D1

Why: Spreading a string gives its characters.

function f(a, b = a + 1) { return b; }
console.log(f(1));

1. Aundefined
2. BNaN
3. C2Correct answer
4. D1

Why: Default parameters can use earlier ones.

1. A'array'
2. B'list'
3. C'undefined'
4. D'object'Correct answer

Why: Use Array.isArray.

1. A-InfinityCorrect answer
2. BInfinity
3. Cundefined
4. D0

Why: It starts from -Infinity and compares upward.

1. AError
2. B[1, 2, 3, 4]
3. C"1,2,34"Correct answer
4. D10

Why: Arrays become strings '1,2,3' and '4'.

1. AError
2. B1Correct answer
3. Cnull1
4. DNaN

Why: null converts to 0 in arithmetic.

1. A1
2. BNaNCorrect answer
3. Cundefined1
4. D0

Why: undefined converts to NaN.

const arr = [1, 2, 3];
arr[5] = 6;
console.log(arr.length);

1. AError
2. B4
3. C6Correct answer
4. D3

Why: Assigning index 5 leaves empty slots at 3 and 4; length is the highest index + 1.

1. A1Correct answer
2. Btrue
3. CNaN
4. D'true'

Why: Unary plus converts to a number.

1. ANaN
2. B'3'
3. C3Correct answer
4. D'52'

Why: Minus converts strings to numbers.

1. A'52'Correct answer
2. B7
3. CNaN
4. D'7'

Why: Plus with a string concatenates.

console.log({ ...{ a: 1, b: 2 }, b: 3 });

1. A{ b: 3 }
2. BError
3. C{ a: 1, b: 3 }Correct answer
4. D{ a: 1, b: 2 }

Why: Later spread properties win.

1. Aundefined
2. BTypeError
3. CtrueCorrect answer
4. Dfalse

Why: All objects, even empty arrays, are truthy.

1. Aundefined
2. BtrueCorrect answer
3. Cfalse
4. DTypeError

Why: [] becomes '' then 0, and false becomes 0.

1. AtrueCorrect answer
2. B"false"
3. CError
4. Dfalse

Why: Any non-empty string is truthy.

1. A"function"Correct answer
2. B"callable"
3. C"undefined"
4. D"object"

Why: Functions report "function".

1. A0
2. Bundefined
3. C3Correct answer
4. D1

Why: A sparse array with 3 empty slots.

1. Aundefined
2. B'default'Correct answer
3. C0
4. Dfalse

Why: || replaces all falsy values.