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:

Self-comparisons: Comparing a value to itself (e.g., x === x)
Impossible ranges: Range checks that can never be satisfied (e.g., x <= 400 && x > 500)
Redundant double comparisons: OR patterns that can be simplified (e.g., x === y || x < y can become x <= y)
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

if (
const value: number
value === 
const value: number
value) {
  // Always true
}

if (
const value: number
value < 
const value: number
value) {
  // Always false
}

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

// Use Number.isNaN() for NaN checks
if (
var Number: NumberConstructor
An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers.
Number.
NumberConstructor.isNaN(number: unknown): boolean
Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
to a number. Only values of the type number, that are also NaN, result in true.
@param ― number A numeric value.
isNaN(
const value: number
value)) {
  // ...
}

Impossible Ranges

❌ Incorrect
✅ Correct

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

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

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

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

Redundant Double Comparisons

❌ Incorrect
✅ Correct

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

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

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

if (
const x: number
x >= 
const y: number
y) {
  // ...
}

Ineffective Checks

❌ Incorrect
✅ Correct

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

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

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

// Or use both bounds when they're actually needed
if (
const x: number
x > 100 && 
const x: number
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.

Equivalents in Other Linters

Oxlint: oxc/const-comparisonsoxc/double-comparisons

Made with ❤️‍🔥 around the world by the Flint team and contributors.