unnecessaryComparisons

Reports comparisons that are always true, always false, or can be simplified.

✅ This rule is included in the ts logical and logicalStrict presets.

This rule detects comparison patterns that are logically unnecessary, impossible, or can be simplified. Such patterns often indicate logic errors, copy-paste mistakes, or overly complex code that should be refactored.

The rule covers several categories of problematic comparisons:

1. Self-comparisons: Comparing a value to itself (e.g., x === x)
2. Impossible ranges: Range checks that can never be satisfied (e.g., x <= 400 && x > 500)
3. Redundant double comparisons: OR patterns that can be simplified (e.g., x === y || x < y can become x <= y)
4. Ineffective checks: Redundant bounds in AND chains (e.g., x < 200 && x <= 299 where the second check is always true when the first is)

Examples

Self-Comparisons

❌ Incorrect

if (value === value) {
  // Always true
}

if (value < value) {
  // Always false
}

✅ Correct

if (value === otherValue) {
  // Compare different values
}

// Use Number.isNaN() for NaN checks
if (Number.isNaN(value)) {
  // ...
}

Impossible Ranges

❌ Incorrect

// Can never be true: no value is both <= 400 AND > 500
if (x <= 400 && x > 500) {
  // Unreachable code
}

// Impossible boundary condition
if (x < 5 && x >= 5) {
  // Never executes
}

✅ Correct

// Valid range: x is between 400 and 500
if (x >= 400 && x <= 500) {
  // ...
}

// Valid narrow range
if (x > 5 && x < 10) {
  // ...
}

Redundant Double Comparisons

❌ Incorrect

// Can be simplified to: x <= y
if (x === y || x < y) {
  // ...
}

// Can be simplified to: x >= y
if (x === y || x > y) {
  // ...
}

✅ Correct

// Use the simpler combined operator
if (x <= y) {
  // ...
}

if (x >= y) {
  // ...
}

Ineffective Checks

❌ Incorrect

// x <= 299 is redundant when x < 200 is already checked
if (x < 200 && x <= 299) {
  // The second check adds nothing
}

// x >= 50 is redundant when x > 100 is already checked
if (x > 100 && x >= 50) {
  // ...
}

✅ Correct

// Just use the stronger constraint
if (x < 200) {
  // ...
}

// Or use both bounds when they're actually needed
if (x > 100 && x < 200) {
  // Valid range check
}

Options

This rule is not configurable.

When Not To Use It

If your codebase relies on dynamic getters or other side effects that could make seemingly-identical expressions return different values, you might want to disable this rule for those specific cases.

Further Reading

• MDN: Comparison operators
• MDN: Logical AND (&&)
• MDN: Logical OR (||)
• MDN: Number.isNaN()

Equivalents in Other Linters

• Oxlint: oxc/const-comparisonsoxc/double-comparisons