If you’ve been learning JavaScript or preparing for interviews, you’ve almost certainly come across the question: What is the difference between == and === in JavaScript?

Although both operators are used to compare values, they work very differently. Choosing the wrong one can introduce subtle bugs that are difficult to track down, especially when JavaScript performs automatic type conversion behind the scenes.

In this guide, you’ll learn the difference between == and === in JavaScript, how type coercion works, when to use each operator, common edge cases, and why most developers prefer strict equality.

What Are Equality Operators in JavaScript?

JavaScript provides two primary equality operators:

  • == (Loose Equality)
  • === (Strict Equality)

Both operators compare two values, but the way they perform the comparison is completely different.

  • == compares values after performing type conversion when necessary.
  • === compares both the value and the data type without converting either operand.

Understanding this difference is essential for writing predictable and bug-free JavaScript code.

20 Essential Questions JavaScript Interview Questions

What is == (Loose Equality)?

The loose equality operator (==) compares two values after attempting to convert them to a common type. This automatic conversion is known as type coercion.

For example:

5 == "5"

Output:

true

Why?

JavaScript converts the string "5" into the number 5 before comparing the values.

Internally, the comparison behaves like this:

Number("5") == 5

Which becomes:

5 == 5

Result:

true

While this behavior may seem convenient, it can also produce unexpected results if you don’t understand how type coercion works.

What is Type Coercion?

Type coercion is JavaScript’s ability to automatically convert one data type into another during certain operations.

This is one of JavaScript’s most unique—and sometimes confusing—features.

Consider these examples:

0 == false

Output:

true

JavaScript converts false into 0.

"" == false

Output:

true

An empty string is converted into 0, and false is also converted into 0.

"10" == 10

Output:

true

The string is converted into a number before comparison.

Understanding these implicit conversions is the key to understanding loose equality.

What is === (Strict Equality)?

The strict equality operator (===) compares both the value and the data type.

No automatic conversion takes place.

Example:

5 === "5"

Output:

false

Although both values appear similar, one is a number while the other is a string.

Another example:

10 === 10

Output:

true

Both operands have the same value and the same data type.

This predictable behavior is why === is generally recommended in JavaScript.

Difference Between == and ===

Feature=====
Compares ValueYesYes
Compares Data TypeNoYes
Performs Type CoercionYesNo
Recommended for General UseNoYes
SaferNoYes

Type Coercion Examples

Let’s look at a few common examples that often surprise developers.

Example 1

5 == "5"

Result:

true

Example 2

5 === "5"

Result:

false

Example 3

true == 1

Result:

true

Because:

Number(true)

becomes

1

Example 4

true === 1

Result:

false

Different data types.

Example 5

[] == false

Output:

true

JavaScript converts both operands before comparison.

This is one reason why developers often avoid loose equality.

Understanding the Abstract Equality Comparison Algorithm

Many articles simply state that “== performs type coercion,” but few explain what actually happens.

When you use ==, JavaScript follows the Abstract Equality Comparison Algorithm defined in the ECMAScript specification. Instead of comparing values directly, the engine checks the types of both operands and decides whether one or both should be converted before comparison.

For example:

"42" == 42

The string "42" is converted to the number 42, after which the comparison becomes:

42 == 42

Similarly:

false == 0

The boolean false is converted to the number 0.

The exact conversion rules depend on the types being compared. While you don’t need to memorize the algorithm, understanding that JavaScript follows a well-defined specification—not random behavior—helps explain why some comparisons produce surprising results.

Edge Cases (NaN, null, and undefined)

Some comparisons behave differently from what many developers expect.

NaN

NaN == NaN

Output:

false

Even with strict equality:

NaN === NaN

Output:

false

To check for NaN, use:

Number.isNaN(value)

null and undefined

null == undefined

Output:

true

However:

null === undefined

Output:

false

This is one of the few intentional behaviors of loose equality.

Zero and False

0 == false

Output:

true

But:

0 === false

Output:

false

When Should You Use ==?

Many developers say, “Never use ==.” While that’s a good rule for beginners, it’s not entirely accurate.

There is one legitimate and widely accepted use case:

if (value == null) {
    // Handles both null and undefined
}

This works because:

null == undefined

evaluates to true, while no other values match this comparison.

This pattern is often used when you intentionally want to check for either null or undefined without writing:

if (value === null || value === undefined)

Outside of this scenario, === is generally the safer and more predictable choice.

Best Practices

When comparing values in JavaScript:

  • Prefer === for most comparisons.
  • Avoid relying on implicit type coercion.
  • Use == only when you intentionally want JavaScript’s conversion behavior, such as checking for both null and undefined.
  • Be cautious when comparing booleans, numbers, strings, and arrays using loose equality.
  • Write comparisons that are clear to other developers, not just to the JavaScript engine.

Following these practices makes your code easier to understand, easier to debug, and less prone to unexpected behavior.

Frequently Asked Questions

Why is === preferred over == in JavaScript?

Because it compares both value and type without performing automatic type conversion, making comparisons more predictable.

Does == compare data types?

No. The loose equality operator performs type coercion before comparing values.

Is == always bad?

No. It has a valid use case when checking whether a value is either null or undefined.

What is type coercion?

Type coercion is JavaScript’s automatic conversion of one data type into another during certain operations, including loose equality comparisons.

Which equality operator should beginners use?

Beginners should use === in almost every situation. It avoids unexpected results caused by implicit type conversion and makes code easier to understand.

Additional Learning Resources

Final Thoughts

Understanding the difference between == and === in JavaScript is about more than passing interviews—it’s about writing reliable and maintainable code.

While loose equality (==) has a few valid use cases, strict equality (===) should be your default choice because it avoids implicit type coercion and produces more predictable results. By understanding how JavaScript compares values, including edge cases involving NaN, null, and undefined, you’ll be better equipped to debug issues and make informed coding decisions.

If you’re preparing for JavaScript interviews, make sure you can explain not only what these operators do, but also why they behave the way they do. Interviewers often look for conceptual understanding, and mastering this topic is a solid step toward becoming a more confident JavaScript developer.