Post cover vs Strict Equality Operator in JavaScript

The triple equality operator === checks strictly whether 2 values are the same:

1 === 1; // => true
1 === '1'; // => false
1 === true; // => false

However, ES2015 specification brings, which behaves almost same way as strict equality operator:, 1); // => true, '1'); // => false, true); // => false

The main question is: when would you use instead of a strict equality check? Let's find out.

Before I go on, let me recommend something to you.

The path to becoming good at JavaScript isn't easy... but fortunately with a good teacher you can shortcut.

Take "Modern JavaScript From The Beginning 2.0" course by Brad Traversy to become proficient in JavaScript in just a few weeks. Use the coupon code DMITRI and get your 20% discount!

1. Strick equality check operator

To begin with, let's refresh quickly how the strict equality operator works.

The strict equality check operator evaluates to true when both values are of the same type and hold the same value.

For example, the following primive values are equal because they're the same type and have the same value:

1 === 1; // => true
'abc' === 'abc'; // => true
true === true; // => true
null === null; // => true
undefined === undefined; // => true

The strict equality operator doesn't perform type coersion of operators. Even if operators hold reasonable same values, but nevertheless of different types, they aren't strictly equal:

1 === '1'; // => false
1 === true; // => false
null === undefined; // => false

When performing the strict equality check on objects, an object is strictly equal only to itself:

const myObject = { prop: 'Value' };
myObject === myObject; // => true

Even if 2 objects have exactly the same properties and values, they're different values:

const myObject1 = { prop: 'Value' };
const myObject2 = { prop: 'Value' };
myObject1 === myObject2; // => false

The above comparison scenarios work exactly the same in, valueB).

The difference between strict equality check and lies in how NaN and how negative zero -0 are treated.

Firstly, NaN (Not A Number) isn't strictly equal to any other value, even with another NaN:

NaN === NaN; // => false
NaN === 1; // => false

Secondly, the strict equality operator doesn't distinguish -0 from +0:

-0 === +0; // => true

The strict equality operator uses the Strict Equality Comparison algorithm.

2., valueB) checks the arguments for equality the same way as the strict equality operator, but with the 2 differences.

Firstly, NaN equals to another NaN value:, NaN); // => true, 1); // => false

Secondly, makes the distinction between -0 and +0:, +0); // => false, in contrast to strict equality operator, uses Same Value Comparison algorithm.

3. Summary

In most of the situations, the strict equality operator is a good way to compare values.

If you'd like to check directly for NaN values or make a more strict distinction between negative and positive zeros, then is a good choice.

Also is useful as a functional way to compare values, for example in functional programming.

Like the post? Please share!

Dmitri Pavlutin

About Dmitri Pavlutin

Software developer and sometimes writer. My daily routine consists of (but not limited to) drinking coffee, coding, writing, overcoming boredom 😉. Living in the sunny Barcelona. 🇪🇸