JavaScript Equality Bedtime Horror

Level 1: The Empty Sandwich

It is like making a sandwich with nothing on either side of the filling, so the only thing left is the slice in the middle. JavaScript looks at two empty spots in a list, keeps the comma between them, and then says it matches a comma. The funny part is that the answer is technically correct while still feeling deeply suspicious.

Level 2: Coercion Trapdoor

Type coercion means a language automatically changes a value from one type to another. For example, JavaScript may turn a number into a string, a string into a number, or an array into a string if an operator asks for it.

Here the visual joke uses [null,null], which is an array with two empty-like values. When JavaScript turns that array into text, it joins the two positions with a comma. Since both values contribute no visible text, the result is just ",". Then == compares that string to the string on the right and says true.

For junior developers, this is one reason linters often warn about == and suggest ===. Loose equality can be convenient, but it also means you need to know the conversion rules. Strict equality is usually easier to reason about: if the two things are not already the same kind of value, they are not equal.

Level 3: Equality Bedtime Story

The book page says:

Type coercion:

[null,null] == ","

true

That final blank stare is earned. JavaScript's loose equality operator, ==, does not simply ask "are these the same type and value?" It runs the Abstract Equality Comparison rules, which may convert one side before comparing. In this case the left side is an array and the right side is a string, so JavaScript tries to turn the array into a primitive value. Arrays usually become strings through toString(), which delegates to join(",").

The nasty little detail is how join treats null and undefined elements. They become empty text inside the joined string, but the separator still appears between array slots. So this happens:

String([null, null]); // ","
[null, null] == ","; // true

Nothing supernatural occurred. The runtime followed the rules exactly, which is somehow worse. The joke works because the book with the JS logo looks like a bedtime story, then casually presents a result that feels like forbidden knowledge. It is the classic JavaScript experience: the specification is internally consistent, and the developer is externally reconsidering their life choices.

This is why experienced teams are suspicious of == in production code. It can be useful when you deliberately want coercion, but most business logic is not improved by asking arrays to negotiate their identity with strings. The safer default is ===, strict equality, because it avoids this conversion dance and compares both type and value. String([null, null]) === "," is true, but [null, null] === "," is false, which is the kind of answer a human might still respect in the morning.

The post message, Try it on your own!, points at the same underlying trick: the array does not become two visible words. It becomes just the separator. The meme is not saying JavaScript is random; it is saying JavaScript has a perfectly documented path to results that look random when you meet them in the wild.