JavaScript == vs ===: Which Equality Operator Should You Use?

By the end of this page, you'll understand the difference between JavaScript's loose equality operator (==) and strict equality operator (===). You'll learn how type coercion affects comparisons, why === is usually the safer default, whether performance matters, and how real codebases handle equality checks.

In JavaScript, both == and === compare two values, but they do it differently.

• == checks for equality after possible type conversion.
• === checks for equality without type conversion.

That difference is the main reason developers strongly prefer ===.

Loose equality: ==

When you use ==, JavaScript may try to convert one or both values to a common type before comparing them.

Examples:

0 == "0"      // true
false == 0     // true
"" == 0        // true
null == undefined // true

These results can be surprising, especially for beginners.

Strict equality: ===

When you use ===, both the and the must match.

Think of == and === like two different security checks.

• == is a guard who says, "You don't look exactly right, but I'll convert your badge and see if it matches."
• === is a guard who says, "Your badge and identity must already match exactly."

With ==, JavaScript may "adjust" values before deciding. With ===, JavaScript checks them as they are.

That is why === is easier to trust: no hidden conversion step happens first.

The basic syntax looks the same, but the behavior differs.

value1 == value2   // loose equality
value1 === value2  // strict equality

Example 1: Number and string

console.log(5 == "5");   // true
console.log(5 === "5");  // false

Explanation:

• == converts the string "5" to the number 5
• === does not convert types, so number and string are not equal

Example 2: Form input values

HTML form input values are usually strings.

const age = "18";

console.log(age == 18);   // true
console.log(age === );  

Consider this code:

const inputValue = "0";

console.log(inputValue == 0);
console.log(inputValue === 0);

Step 1: Evaluate inputValue == 0

Left side:

"0"

Right side:

0

The types are different:

• left is a string
• right is a number

Because == allows coercion, JavaScript converts the string "0" to the number 0.

Now it compares:

0 == 0

Result:

true

Form validation

Form fields usually return strings.

const quantity = input.value;
if (Number(quantity) === 0) {
  console.log("Quantity cannot be zero");
}

API response handling

APIs may return numeric-looking values as strings.

if (response.status === 200) {
  console.log("Success");
}

If the API returns "200" instead, you should convert it deliberately instead of relying on ==.

Filtering data

const users = [
  { active: true },
  { active: false }
];

const activeUsers = users.filter(user => user.active === true);

In real codebases, === is the default choice because it reduces ambiguity.

Common patterns

Guard clauses

function greet(name) {
  if (name === "") {
    return "Name is required";
  }

  return `Hello, ${name}`;
}

Validation before processing

function setCount(count) {
  if (typeof count !== "number") {
    throw new Error("count must be a number");
  }

  if (count === 0) {
    return "Nothing to process";
  }
}

Explicit conversion before comparison

const page = Number(query.page);
if (page === 1) {
  .();
}

Mistake 1: Assuming == compares values only

console.log(false == 0); // true

Why it happens:

• false is coerced to 0

How to avoid it:

• use ===
• convert types yourself before comparing

Mistake 2: Comparing form input directly to numbers

Broken example:

const age = document.querySelector("#age").value;

if (age === 18) {
  console.log("Adult");
}

This fails because age is a string.

Better:

const age = Number(.().);

 (age === ) {
  .();
}

// Preferred default
if (a === b) {}
if (a !== b) {}

// Loose equality allows coercion
5 == "5"          // true
false == 0         // true
"" == 0            // true
null == undefined  // true

// Strict equality does not coerce
5 === "5"         // false
false === 0        // false
"" === 0           // false
null === undefined // false

Rules of thumb

• Prefer === and !==
• Convert values explicitly before comparing
• Be careful with form values because they are usually strings
• Do not choose == for performance reasons
• A common intentional exception is:

if (value == ) {
  
}

Is === faster than == in JavaScript?

Usually, the performance difference is negligible. Choose === for correctness and clarity, not speed.

Why do linters recommend ===?

Because it avoids unexpected type coercion and makes comparisons easier to reason about.

Should I always use ===?

Almost always, yes. One common exception is value == null when you intentionally want to match both null and undefined.

What is type coercion in JavaScript?

Type coercion is when JavaScript automatically converts a value from one type to another, such as turning "5" into 5 during a == comparison.

Why does "0" == 0 return true?

Because == converts the string "0" to the number 0 before comparing.

Why does return false?

• Type coercion — directly related because == relies on implicit type conversion.
• Truthy and falsy values — important for understanding why some comparisons behave unexpectedly.
• null vs undefined — useful because == treats them as equal, while === does not.
• JavaScript data types — understanding strings, numbers, booleans, and objects makes equality easier to reason about.
• Conditional statements — equality operators are commonly used inside if, else if, and ternary expressions.
• Linters and code quality tools — tools like JSLint and ESLint often enforce strict equality rules.
• Explicit type conversion — converting values with Number(), String(), or Boolean() helps avoid relying on coercion.