In JavaScript, there are four equality operators that are used to compare values and return a boolean result. These operators include:

  1. == (Equality Operator): This operator checks for equality between two values.
  2. != (Inequality Operator): This operator checks for inequality between two values.
  3. === (Strict Equality Operator): This operator checks for strict equality, meaning the values being compared must have the same type and value.
  4. !== (Strict Inequality Operator): This operator checks for strict inequality, meaning the values being compared must either have a different type or a different value.

The distinction between the regular equality operators (== and !=) and the strict equality operators (=== and !==) is important.

When using the regular equality operators, JavaScript will attempt to convert the second operand to the type of the first operand before making the comparison. This can lead to unexpected results, especially when comparing different data types. The strict equality operators, on the other hand, do not perform any type coercion. They require both the type and value to be the same for the comparison to return true.

Let’s take a look at some examples to illustrate the behavior of these operators:

const a = true;

a == true;      // true
a === true;     // true

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

As you can see, the regular equality operator (==) considers the value of 1 and '1' to be equal, while the strict equality operator (===) differentiates between the two, considering them unequal due to the difference in type.

It’s important to note that objects cannot be directly compared for equality. Two objects are never equal to each other, even if they have the same properties and values. The only case where a comparison might return true is if two variables reference the same object.

There are also a few peculiarities to be aware of:

  • NaN (Not-a-Number) is always considered different from NaN when using any of the equality operators.
  • The values null and undefined are considered equal when compared with the equality operator (==) in non-strict mode, but not with the strict equality operator (===).
NaN == NaN;               // false

null == undefined;        // true
null === undefined;       // false

To conclude, it is important to understand the differences between the regular equality operators (== and !=) and the strict equality operators (=== and !==). By using the appropriate operator, you can ensure that your comparisons are accurate and avoid any unexpected results.

Tags: JavaScript, Equality Operators, Type Coercion, Data Types, Strict Equality, Non-strict Equality