After hoisting, interviewers love dropping one-liners like:

console.log([] + []);
console.log([] + {});
console.log({} + []);
console.log(NaN === NaN);

…and watching whether you guess, freeze, or calmly walk the coercion rules.

This post is only output-based type coercion / equality questions.

Try each snippet yourself first. Answers are hidden — click Show answer when you’re ready.

TL;DR — what interviewers are testing

One-line mental model

+ asks both sides to become primitives.

If either side is a string (after that), you get concatenation.

Otherwise you get number math — and weird values become NaN.

Warm-up: how + really decides

When JS hits a + b, it roughly does:

1) Convert both sides to primitives (ToPrimitive)
2) If either result is a string → String(a) + String(b)   // concat
3) Else → Number(a) + Number(b)                         // math

For plain objects / arrays, ToPrimitive usually ends up calling .toString():

That’s enough to solve most [] + {} style questions.

How to use this post

1. Read the snippet
2. Say the output out loud (or write it down)
3. Only then open Show answer
4. Read the step-by-step — don’t only memorize the final print

Q1 — Classic [] + []

console.log([] + []);

""

(empty string — looks like a blank line)

Step by step

1. + wants primitives from both arrays.
2. String([]) → "" (empty array joins to empty string).
3. "" + "" → "".

Interview tip: People often say 0 or []. Wrong. Empty array stringifies to "", so you get string concat of nothing.

Q2 — [] + {}

console.log([] + {});

[object Object]

Step by step

1. Left: String([]) → ""
2. Right: String({}) → "[object Object]"
3. One side is a string → concat → "" + "[object Object]" → "[object Object]"

Why not math? Because after ToPrimitive, you already have a string on the left (""), so + stays in string mode.

Q3 — ({} + []) with parentheses

console.log({} + []);
console.log(({} + []));

[object Object]
[object Object]

Step by step

1. Inside console.log(...) / parentheses, {} is an object literal.
2. String({}) → "[object Object]"
3. String([]) → ""
4. Concat → "[object Object]" + "" → "[object Object]"

Same printable result as [] + {}, different operand order — both sides still stringify.

Q4 — The famous bare {} + [] trap

eval('{} + []');
eval('({} + [])');

0
[object Object]

Step by step

1. Bare {} + [] at statement start: JS can parse {} as an empty block, not an object.
2. What’s left is unary +[].
3. +[] → Number([]) → 0.
4. Wrap it: ({} + []) forces an expression → object + array → "[object Object]".

Interview tip: Always ask: “Is this a statement or an expression?” Parentheses (or console.log) change the parse.

Q5 — Arrays with values still concat

console.log([1, 2] + [3, 4]);

1,23,4

Step by step

1. String([1, 2]) → "1,2"
2. String([3, 4]) → "3,4"
3. "1,2" + "3,4" → "1,23,4"

No spaces. No nested array. Just two strings glued together.

Q6 — NaN === NaN

console.log(NaN === NaN);
console.log(NaN == NaN);

false
false

Step by step

1. IEEE-754 rule: NaN is never equal to anything, including itself.
2. So both === and == return false.

Correct checks

Number.isNaN(NaN);     // true  ← prefer this
Object.is(NaN, NaN);   // true
isNaN('hello');        // true  ← coerces first (sloppy)
Number.isNaN('hello'); // false ← no coercion

Interview tip: Saying “use isNaN” is incomplete. Prefer Number.isNaN or Object.is.

Q7 — How NaN is born (and stays sticky)

console.log(Number('abc'));
console.log('abc' - 1);
console.log(undefined + 1);
console.log(NaN + 5);
console.log(typeof NaN);

NaN
NaN
NaN
NaN
number

Step by step

1. Failed number conversion → NaN.
2. Any math with NaN → NaN (it “poisons” the expression).
3. typeof NaN is still "number" — weird but true.

One-liner: NaN means “invalid number,” not “not a number type.”

Q8 — Object.is vs === (NaN + -0)

console.log(Object.is(NaN, NaN));
console.log(Object.is(+0, -0));
console.log(+0 === -0);

true
false
true

Step by step

1. Object.is treats NaN as equal to NaN.
2. Object.is treats +0 and -0 as different.
3. === does the opposite on zeros: +0 === -0 is true.

Use this when they ask “when is Object.is not the same as ===?”

Q9 — + vs - with strings

console.log('5' + 2);
console.log('5' - 2);
console.log('5' * '2');
console.log('5' + '2');

52
3
10
52

Step by step

1. + with a string → concat → "52".
2. - / * always do numeric conversion → 3, 10.
3. '5' + '2' is pure string concat → "52".

Rule of thumb: Only + is overloaded for strings. -, *, /, % are always math.

Q10 — Booleans in math

console.log(true + true);
console.log(true + false);
console.log(true + '1');
console.log(false - true);

2
1
true1
-1

Step by step

1. true → 1, false → 0 in numeric context.
2. true + true → 1 + 1 → 2.
3. true + '1' hits a string → "true" + "1" → "true1".
4. false - true → 0 - 1 → -1.

Q11 — Unary plus / Number on [] and {}

console.log(+[]);
console.log(+{});
console.log(Number([]));
console.log(Number({}));

0
NaN
0
NaN

Step by step

1. +[] → Number([]) → Number("") → 0.
2. +{} → Number("[object Object]") → NaN.

This is why bare {} + [] can print 0 (unary plus on []).

Q12 — null / undefined with +

console.log(null + 1);
console.log(undefined + 1);
console.log([] + null);
console.log(null + []);

1
NaN
null
null

Step by step

1. Numeric: null → 0, so null + 1 → 1.
2. Numeric: undefined → NaN, so undefined + 1 → NaN.
3. With arrays, + becomes string concat: "" + "null" → "null".

Same characters printed for the last two — both are the string "null".

Q13 — null == undefined (and friends)

console.log(null == undefined);
console.log(null === undefined);
console.log(null == 0);
console.log(undefined == 0);
console.log(null == false);

true
false
false
false
false

Step by step

1. Spec special case: null == undefined is true.
2. === checks type too → false.
3. null / undefined do not loosely equal 0 or false.

Memorize this trio: null == undefined is the exception people forget.

Q14 — Empty array vs empty string vs 0

console.log([] == 0);
console.log([] == '');
console.log('' == 0);
console.log([] == false);
console.log(false == '');

true
true
true
true
true

Step by step (high level)

1. == keeps coercing until it can compare primitives.
2. [] becomes "", then often 0.
3. false becomes 0.
4. So these “different-looking” values all meet in the middle as 0 / "".

Interview tip: This is why seniors say never use == unless you mean it. Prefer ===.

Q15 — The viral [] == ![]

console.log(![]);
console.log([] == ![]);

false
true

Step by step

1. [] is truthy, so ![] → false.
2. Expression becomes [] == false.
3. false → 0, [] → "" → 0.
4. 0 == 0 → true.

Looks impossible. Totally consistent with coercion rules.

Q16 — Truthy / falsy surprises

console.log(Boolean([]));
console.log(Boolean({}));
console.log(Boolean(''));
console.log(Boolean(0));
console.log(Boolean(NaN));
console.log(Boolean(null));
console.log(!!'0');

true
true
false
false
false
false
true

Falsy list (memorize — only these):

false, 0, -0, 0n, '', null, undefined, NaN

Everything else is truthy — including [], {}, and '0'.

Q17 — Reference equality for objects/arrays

console.log([] === []);
console.log({} === {});
console.log([] == []);
console.log({} == {});

const a = [];
console.log(a === a);

false
false
false
false
true

Step by step

1. Objects/arrays compare by reference, not contents.
2. Each {} / [] literal creates a new value in memory.
3. Same variable refers to the same reference → true.

== does not deep-compare objects either.

Q18 — typeof null classic

console.log(typeof null);
console.log(typeof []);
console.log(typeof {});
console.log(typeof NaN);
console.log(Array.isArray([]));

object
object
object
number
true

Step by step

1. typeof null === "object" is a decades-old language bug/legacy quirk.
2. Arrays are objects → "object"; detect with Array.isArray.
3. NaN is a number.

Safe null check: value === null (not typeof).

Q19 — Floating point equality

console.log(0.1 + 0.2);
console.log(0.1 + 0.2 === 0.3);

0.30000000000000004
false

Why: Binary floating point can’t represent 0.1 / 0.2 exactly.

Not a coercion bug — a precision bug. Mention Number.EPSILON or decimal libraries if they push deeper.

Q20 — Mixed bag rapid fire

console.log([] + {});
console.log({} + []);
console.log([] + [] + 'ok');
console.log('' + 1 + 0);
console.log('' - 1 + 0);
console.log(true + true + true);
console.log(!![]);
console.log(Number.isNaN(NaN) && !(NaN === NaN));

[object Object]
[object Object]
ok
10
-1
3
true
true

Quick why

1. First two: stringified object (inside console.log, {} is an expression).
2. "" + "" + "ok" → "ok".
3. "" + 1 + 0 → "10" (left-to-right concat).
4. "" - 1 becomes numeric -1, then -1 + 0 → -1.
5. true thrice → 3.
6. [] truthy → true.
7. Best NaN check + === self-inequality both hold → true.

Practice round (no spoilers)

Predict each line, then check in a REPL.

P1

console.log([] + []);
console.log([] + 1);
console.log([1] + [2]);

1
12

"", then "1", then "1"+"2".

P2

console.log(NaN === NaN);
console.log(Object.is(NaN, NaN));
console.log(Number.isNaN('NaN'));

false
true
false

Number.isNaN does not coerce strings.

P3

console.log([] == ![]);
console.log({} == !{});

true
false

!{} → false → {} == false → NaN == 0 path fails → false.

P4

console.log(null + null);
console.log(undefined + undefined);
console.log(null == undefined);

0
NaN
true

null → 0; undefined → NaN; loose equal special case.

P5

console.log('10' - 5 + '5');
console.log('10' + 5 - '5');

55
100

Left: (10-5)+"5" → "55". Right: "105" - "5" → 100.

Cheat sheet — say this in the interview

1. + with a string involved → concatenation
2. [] → "" → 0   |   {} → "[object Object]" → NaN
3. Bare {} at statement start may be a block
4. NaN === NaN → false; use Number.isNaN / Object.is
5. Prefer ===; == is a coercion maze
6. Only these are falsy: false, 0, -0, 0n, '', null, undefined, NaN
7. typeof null → "object" (legacy)

Wrap-up

Coercion questions in JS interviews are almost always output prediction, not definitions.

Master these four:

1. How + chooses concat vs math
2. What [] / {} become as string/number
3. Why NaN === NaN is false
4. Why == makes [] == ![] “true”

Everything else is a remix of those rules.

If useful, I can do a follow-up in the same format for this binding, closures, or optional chaining / nullish coalescing output traps.