Value Comparison

Introduction

Value Comparison refers to the process of evaluating whether two values are equal, not equal, greater than, less than, or otherwise related based on their contents or semantics. It is one of the most fundamental operations in programming and underpins logic, control flow, sorting algorithms, searching, assertions in tests, and more.

Understanding value comparison involves more than just using operators like == or !=—you must also consider:

Type compatibility
Coercion behavior
Reference vs value equality
Deep vs shallow comparison

This article dives deep into how value comparison works across different programming paradigms and languages.

Types of Comparison

Type	Description
Equality (`==`)	Checks if two values are “equivalent”
Strict Equality (`===`)	Checks value and type equality
Relational	Compares relative magnitude (`<`, `>`, etc.)
Reference Comparison	Checks if two variables refer to the same object
Deep Comparison	Recursively checks contents of compound structures

Equality Operators

JavaScript

"5" == 5     // true (loose equality with coercion)
"5" === 5    // false (strict equality without coercion)
null == undefined // true
null === undefined // false

Python

5 == 5.0     # True → values considered equal
"5" == 5     # False → no coercion

Python’s == checks value equality, but is type-aware—unlike JavaScript.

Reference vs Value Equality

In many languages, comparing objects checks if they point to the same memory address (reference equality), not whether their contents match.

JavaScript

let a = { x: 1 };
let b = { x: 1 };
a == b   // false
a === b  // false
a === a  // true

To compare actual content, use deep comparison functions (see later).

Python

a = [1, 2]
b = [1, 2]
a == b    # True → contents match
a is b    # False → different memory addresses

In Python:

== → value equality
is → reference equality

Relational Operators

Operator	Meaning	Example
`<`	Less than	`3 < 5 → True`
`>`	Greater than	`5 > 3 → True`
`<=`	Less than or equal	`5 <= 5 → True`
`>=`	Greater or equal	`6 >= 7 → False`

These operators require operands to be of compatible types.

Comparison in Different Languages

Language	Loose Equality	Strict Equality	Deep Comparison	Notes
JavaScript	`==`	`===`	`_.isEqual()`	Coercion in `==`, avoid when unsure
Python	N/A	`==` only	`==` or `deepdiff`	`==` checks structure for lists/dicts
Java	`equals()`	`==` for references	Use `Objects.equals()` or `equals()`
C	N/A	`==` (primitive)	Manual struct compare	No built-in deep comparison
Go	`==`	`==`	Custom functions	Works for comparable types only
Ruby	`==`, `eql?`, `equal?`	All different	`==` deep for arrays/hashes

Truth Tables: JavaScript Equality

console.log(0 == "0");        // true
console.log(0 === "0");       // false
console.log(null == undefined); // true
console.log([] == false);     // true
console.log([] === false);    // false

Deep Comparison

To check whether complex data structures are structurally equivalent, you need deep comparison.

JavaScript (using Lodash)

_.isEqual({ x: 1 }, { x: 1 }) // true

Python

from deepdiff import DeepDiff

DeepDiff({'x': 1}, {'x': 1})  # returns {}

Java

Objects.equals(list1, list2); // Shallow equality
list1.equals(list2);          // Deep if implemented correctly

Operator Overloading and Custom Equality

Python:

class Person:
    def __init__(self, name): self.name = name
    def __eq__(self, other): return self.name == other.name

a = Person("Alice")
b = Person("Alice")
print(a == b)  # True

Here, == invokes __eq__.

Java:

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Person)) return false;
    Person p = (Person) o;
    return this.name.equals(p.name);
}

Edge Cases

Case	Explanation
`NaN == NaN` → false	`NaN` is not equal to anything, even itself
`null == undefined` (JS) → true	Special coercion rule in JS
`[] == false` → true (JS)	Array coerced to falsy
`"0" == false` → true (JS)	Multiple layers of coercion
`+0 === -0` → true (JS/Python)	Treated as equal

Type Coercion in Comparisons

In JavaScript, loose equality (==) triggers coercion.

"5" == 5   // true → string coerced to number
false == 0 // true

Avoid these by using ===.

In Python, == does not coerce:

"5" == 5   # False

Strict Comparison (Best Practice)

Language	Strict Operator	Use for
JavaScript	`===`, `!==`	Avoids coercion
Python	`==`, no coercion	Safe default
TypeScript	`===`	Same as JavaScript
PHP	`===`	Type-sensitive

Tools and Techniques

Tool / Concept	Description
DeepDiff (Python)	Detects changes between objects deeply
Lodash `_.isEqual()`	Deep comparison utility in JS
Jest `toEqual()`	Deep equality in tests
`JSON.stringify(obj1) === JSON.stringify(obj2)`	Quick check in JS
`id(a) == id(b)`	Python reference check

Comparisons in Testing

In unit testing, deep comparison is often required:

JavaScript (Jest)

expect(obj1).toEqual(obj2)

Python (unittest)

self.assertEqual(obj1, obj2)

Performance Considerations

Shallow comparison is fast (pointer or primitive check)
Deep comparison is O(n) in worst case (structural check)
Always prefer shallow unless deep comparison is necessary

Best Practices

Practice	Why It Matters
Use strict equality (`===`) in JS	Avoids type coercion bugs
Avoid comparing objects by reference (unless intentional)	Prevents false negatives
Use built-in deep comparison tools	Ensures accuracy, readability
Implement custom `equals`/`__eq__` methods	For domain-specific comparisons
Avoid comparing `NaN` directly	Use `isNaN()` or `math.isnan()`