eslint-plugin-no-object-comparison

An ESLint plugin that prevents unsafe comparisons in TypeScript. Uses the type system to detect when comparisons will fail silently.

Installation

``bash
pnpm add -D eslint-plugin-no-object-comparison
`

Requirements: ESLint >= 8, TypeScript >= 5, @typescript-eslint/parser >= 6

Important: This plugin requires typed linting to be enabled. You must configure parserOptions.project to point to your tsconfig.json.

Quick Start

`javascript
// eslint.config.js
import tsParser from '@typescript-eslint/parser';
import noObjectComparison from 'eslint-plugin-no-object-comparison';

export default [
{
files: ['/.ts', '/.tsx'],
languageOptions: {
parser: tsParser,
parserOptions: { project: './tsconfig.json' },
},
},
noObjectComparison.configs.recommended,
];
`

Rules Overview

| Rule | Description | Recommended |
|------|-------------|:-----------:|
| object-equality | Prevent === on objects | error |
| object-relational | Prevent < > on objects | error |
| loose-type | Prevent comparisons with any | error |
| nan-comparison | Prevent x === NaN | error |
| self-comparison | Prevent x !== x | error |
| floating-point-equality | Prevent 0.1 + 0.2 === 0.3 | error |
| string-number-relational | Prevent '10' < '2' | error |
| symbol-literal-comparison | Prevent Symbol() === Symbol() | error |
| object-literal-switch-case | Prevent case {id:1}: | error |
| boxed-primitive-comparison | Prevent new String() === new String() | error |
| array-includes-object | Prevent arr.includes({}) | warn |
| collection-reference-lookup | Prevent map.get({}) | warn |
| collection-object-key | Prevent map.set(obj, val) | warn |
| json-stringify-comparison | Prevent JSON.stringify() comparisons | warn |

---

Rules

$3

Prevents comparing objects with === or !==. Objects are compared by reference, not value.

`typescript
// Bad - always false (different references)
if (user1 === user2) { }
if ({ id: 1 } === { id: 1 }) { }

// Good
if (user1.id === user2.id) { }
`

Full documentation

---

$3

Prevents relational comparisons (<, >, <=, >=) on objects without a valueOf method.

`typescript
// Bad - objects coerce to '[object Object]'
if (user1 < user2) { }

// Good - compare primitive properties
if (user1.age < user2.age) { }
`

Full documentation

---

$3

Prevents comparisons involving any or unknown types, which bypass type safety.

`typescript
// Bad - type system can't verify this
const data: any = fetchData();
if (data === user) { }

// Good - narrow the type first
if (isUser(data) && data.id === user.id) { }
`

Full documentation

---

$3

Prevents comparing with NaN using equality operators. NaN is not equal to anything, including itself.

`typescript
// Bad - always false
if (x === NaN) { }
if (x !== NaN) { } // always true

// Good
if (Number.isNaN(x)) { }
`

Full documentation

---

$3

Prevents comparing a variable to itself, which is often an opaque NaN check or a typo.

`typescript
// Bad - opaque NaN check
if (x !== x) { }

// Good - explicit NaN check
if (Number.isNaN(x)) { }
`

Full documentation

---

$3

Prevents strict equality on floating-point arithmetic, which suffers from precision issues.

`typescript
// Bad - false due to IEEE 754
if (0.1 + 0.2 === 0.3) { }

// Good - use epsilon comparison
if (Math.abs((0.1 + 0.2) - 0.3) < Number.EPSILON) { }
`

Full documentation

---

$3

Prevents relational comparisons on numeric strings, which compare lexicographically.

`typescript
// Bad - '9' > '10' is true (lexicographic)
if ('10' < '2') { }

// Good - convert to numbers
if (Number('10') < Number('2')) { }
`

Full documentation

---

$3

Prevents comparing Symbol() calls. Each call creates a unique symbol.

`typescript
// Bad - always false (unique symbols)
if (Symbol('id') === Symbol('id')) { }

// Good - use Symbol.for() for shared symbols
if (Symbol.for('id') === Symbol.for('id')) { }
`

Full documentation

---

$3

Prevents object literals in switch cases. Switch uses === which compares by reference.

`typescript
// Bad - case never matches
switch (value) {
case { type: 'admin' }: break;
}

// Good - compare primitives
switch (value.type) {
case 'admin': break;
}
`

Full documentation

---

$3

Prevents comparing boxed primitives (new String, new Number, new Boolean), which are objects.

`typescript
// Bad - false (different objects)
new String('a') === new String('a')

// Good - use primitives
'a' === 'a'
String(x) === String(y)
`

Full documentation

---

$3

Prevents using includes(), indexOf(), lastIndexOf() with object literals or new expressions.

`typescript
// Bad - never finds (different reference)
users.includes({ id: 1 })
arr.includes(new User())

// Good - use find/some
users.find(u => u.id === 1)
users.some(u => u.id === 1)
`

Full documentation

---

$3

Prevents using object literals in Map/Set lookup methods (get, has, delete).

`typescript
// Bad - never finds (different reference)
map.get({ id: 1 })
set.has({ id: 1 })

// Good - use stored reference
const key = { id: 1 };
map.set(key, 'value');
map.get(key); // works
`

Full documentation

---

$3

Prevents using non-primitive keys in Map.set() and Set.add(). Object keys require keeping the exact reference.

`typescript
// Bad - error-prone, must keep reference
map.set(user, 'data')
set.add(config)

// Good - use primitive keys
map.set(user.id, 'data')

// Good - use WeakMap for object keys
weakMap.set(user, 'data')
`

Full documentation

---

$3

Prevents comparing JSON.stringify() results. Key order isn't guaranteed and some values are dropped.

`typescript
// Bad - unreliable
JSON.stringify(a) === JSON.stringify(b)

// Good - use deep equality library
import { isEqual } from 'lodash';
isEqual(a, b)
`

Full documentation

---

Configs

| Rule | recommended | strict |
|------|:-----------:|:------:|
| object-equality | 🔴 | 🔴 |
| object-relational | 🔴 | 🔴 |
| loose-type | 🔴 | 🔴 |
| nan-comparison | 🔴 | 🔴 |
| self-comparison | 🔴 | 🔴 |
| floating-point-equality | 🔴 | 🔴 |
| string-number-relational | 🔴 | 🔴 |
| symbol-literal-comparison | 🔴 | 🔴 |
| object-literal-switch-case | 🔴 | 🔴 |
| boxed-primitive-comparison | 🔴 | 🔴 |
| array-includes-object | 🟡 | 🔴 |
| collection-reference-lookup | 🟡 | 🔴 |
| collection-object-key | 🟡 | 🔴 |
| json-stringify-comparison | 🟡 | 🔴 |

🔴 error 🟡 warn

$3

Core rules as errors, optional rules as warnings. Includes indirectReferences: 'warn' for lookup rules. Best for most projects.

`javascript
noObjectComparison.configs.recommended
`

$3

All rules as errors, with indirectReferences: 'error' for lookup rules. For maximum safety.

`javascript
noObjectComparison.configs.strict
`

Inline Suppression

`typescript
// eslint-disable-next-line no-object-comparison/object-equality
if (obj1 === obj2) { }
``

License

MIT