In javascript equality sign= is used for assigning variables so we use something different to check equality.
In javascript, we have three ways to check equality:
- double equals
== - triple equals
=== Object.is()
== (double equals)
Double equals will allow coercion
this is the algorithm for double equals:
1 – if types are the same do the rest of the calculations with triple equals
2 – null and undefined are equal to each other.
3 – if any side is reference type call ToPrimitive()
4 – if we have two different primitive types convert both of them to numbers then do the equality check.
Since double equals allow coercion it allows some corner cases as well
for example
[] == ![] // true
For not dealing with corner cases we shouldn’t use these with double equals:
- don’t use 0,””, ” ”
- don’t use reference types
- don’t compare with a boolean
If the types are equal it will send it to triple equals anyway
=== (triple equals)
It doesn’t allow coercion. first, it checks the types if the types are equal it will check values then it will check equality.
1 === "1" //Since the types are not equal its false
Object.is()
It behaves the same as the triple-equals operator except NaN and +0 and -0.
1 === 1; // true
Object.is(1, 1); // true
+0 === -0; // true
Object.is(+0, -0); // false
NaN === NaN; // false
Object.is(NaN, NaN); // true
