Understanding JavaScript Comparable: Strict Equality (===) in Depth

In JavaScript, comparing values is a fundamental operation. While JavaScript offers several comparison methods, strict equality, denoted by ===, stands out as the most reliable and frequently used in most scenarios. This article delves into the intricacies of Javascript Comparable operations using strict equality, explaining how it works, its behavior with different data types, and why it’s often the preferred choice for developers.

const num = 0;
const obj = new String("0");
const str = "0";

console.log(num === num);   // true
console.log(obj === obj);   // true
console.log(str === str);   // true

console.log(num === obj);   // false
console.log(num === str);   // false
console.log(obj === str);   // false

console.log(null === undefined); // false
console.log(obj === null);    // false
console.log(obj === undefined); // false

How Strict Equality Works in JavaScript

Strict equality in JavaScript operates without type coercion. This means that before comparing two values, JavaScript does not attempt to convert either value to another type. The comparison is straightforward and adheres to these rules:

• Different Types: If the two values being compared have different types, they are always considered unequal. For instance, comparing a number to a string, even if they represent the same numerical value, will result in false.
• Same Type, Non-Numbers: If both values are of the same type, are not numbers, and hold the same value, they are considered equal. This applies to strings, booleans, objects, and symbols. For objects, it’s important to note that strict equality checks if they are the same object reference, not if they have the same properties.
• Numbers: When comparing numbers, strict equality has specific rules to handle edge cases:
  • If both values are not NaN (Not-a-Number) and have the same numerical value, they are equal.
  • +0 (positive zero) and -0 (negative zero) are considered equal. This is due to how floating-point numbers are represented in JavaScript, where both can occur but are often treated as the same in most practical contexts.
  • NaN is never equal to any other value, including itself. This is a unique characteristic of NaN in JavaScript and is used to represent the result of invalid or undefined mathematical operations.

The Nuances of Numbers: +0, -0, and NaN in JavaScript Comparisons

JavaScript’s handling of numbers in strict equality addresses some specific scenarios related to floating-point arithmetic.

Zero: Positive and Negative

In mathematical computations, particularly in areas like calculus and complex analysis, the sign of zero can be significant. JavaScript, following IEEE 754 standards for floating-point numbers, distinguishes between positive zero (+0) and negative zero (-0). However, in most common JavaScript programming scenarios, this distinction is irrelevant. Therefore, strict equality (===) treats +0 and -0 as equal, simplifying comparisons in typical use cases.

NaN: The Not-a-Number Value

NaN arises as a result of operations that do not produce a valid numerical value, such as dividing by zero (although in JavaScript, dividing by zero results in Infinity or -Infinity, not NaN, operations like 0/0 or parsing a non-numeric string into a number using parseInt("hello") result in NaN). A key characteristic of NaN is that it is not equal to any other value, including itself.

console.log(NaN === NaN); // false

To check if a value is NaN, you should use the global function isNaN() or, more reliably, Number.isNaN(). Number.isNaN() is more precise as it doesn’t suffer from the coercion issues that isNaN() can have.

Strict Equality in Array Methods and Switch Statements

Strict equality is not just a standalone operator; it is also used internally by several JavaScript methods and constructs, impacting how they function, especially when working with arrays and conditional logic.

Array Index-Finding Methods

Methods like Array.prototype.indexOf(), Array.prototype.lastIndexOf(), and their TypedArray counterparts rely on strict equality to find elements within an array. This means that these methods will only find elements that are strictly equal to the search value.

A crucial implication of this is when dealing with NaN values in arrays. Because NaN === NaN is false, indexOf(NaN) will never successfully find a NaN value within an array. It will always return -1, indicating that the value was not found.

console.log([NaN].indexOf(NaN));  // -1

switch Statements

Similarly, switch statements in JavaScript use strict equality to match case values with the switch expression. Therefore, using NaN as a case value will never result in a match, because no value will ever be strictly equal to NaN.

switch (NaN) {
  case NaN:
    console.log("Surprise!"); // Nothing is logged
    break;
  default:
    console.log("Default case"); // Default case is logged
}

In summary, strict equality (===) in JavaScript is a cornerstone of value comparison. Its behavior is predictable and type-sensitive, making it ideal for most comparison tasks. Understanding its specific handling of numbers, particularly +0, -0, and NaN, and its application in array methods and switch statements is crucial for writing robust and bug-free JavaScript code. When in doubt about which comparison to use, strict equality is often the safest and most accurate choice for ensuring javascript comparable operations behave as expected.