What is the difference between == and ===?

Q: What is the difference between == and ===?

**Target Audience:** Engineers preparing for JavaScript fundamentals interviews. **Difficulty:** Easy > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every comparison below was actually run in Node — not recited from memory. ## 1. Why This Even Matters — A Story First Imagine two shipping labels: one says "5 kg" and the other says "5000 g." A loose inspector (==) converts both to the same unit and says they match. A strict inspector (===) looks at the literal label text and says they do not match, because one says kilograms and the other says grams — even though the underlying weight is identical. JavaScript ships with both inspectors, and picking the wrong one for the job causes real bugs. ## 2. The Core Idea 📌 **Interview term:** `==` (loose equality) coerces operands of different types to a common type before comparing. `===` (strict equality) never coerces — different types are immediately unequal,

The problem

Question presented to candidate: "What's the difference between == and === in JavaScript, and why do most style guides tell you to always use ===?"

What a strong answer should cover:

📌 Interview term: loose equality (==) — compares two values after converting them to a common type when their types differ. Verified directly: 1 == "1" is true because the string is coerced to a number first.
📌 Interview term: strict equality (===) — compares both type and value, with no coercion at all. Verified: 1 === "1" is false because a number and a string are never equal under ===, regardless of their values.
A precise answer names the coercion rules that make == unpredictable: null == undefined is true (a special-cased pair — they equal each other and nothing else under ==), 0 == false is true, and "" == false is true — verified directly.
📌 Interview term: the classic gotcha — [] == ![] evaluates to true. Verified by tracing it step by step: ![] evaluates first (an empty array is truthy, so ! of it is false), leaving [] == false, which coerces the array to a primitive ("") and then to a number (0), matching false's own 0.
NaN == NaN is false under both operators — coercion never makes NaN equal to anything, including itself — verified directly.

Clarifying questions expected:

None — this is a definitional/comparison question; the strong move is naming the coercion mechanism precisely rather than just "== is looser."

Code / implementation expected: Optional — walking through 2-3 concrete coercion examples (including the null == undefined special case) demonstrates real understanding better than reciting the rule from memory.

equality

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals interviews. Difficulty: Easy

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every comparison below was actually run in Node — not recited from memory.

1. Why This Even Matters — A Story First

Imagine two shipping labels: one says "5 kg" and the other says "5000 g." A loose inspector (==) converts both to the same unit and says they match. A strict inspector (===) looks at the literal label text and says they do not match, because one says kilograms and the other says grams — even though the underlying weight is identical. JavaScript ships with both inspectors, and picking the wrong one for the job causes real bugs.

2. The Core Idea

📌 Interview term: == (loose equality) coerces operands of different types to a common type before compa

The solution is hidden so you can try first

5 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal coercion cases for == vs ===, including the [] == ![] gotcha traced step by step