equalityOperators

Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.

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

The loose equality operators (== and !=) perform type coercion before comparison, which can lead to surprising and confusing behavior. Strict equality operators (=== and !==) compare both value and type without coercion, making comparisons more predictable. Therefore, it is almost always preferable to use the strict equality operators.

Note

This rule only handles comparisons where neither operand is a nullish literal (null or undefined). Null/undefined checks are the one major exception to the rule that strict equality is always preferable, and linting around them is handled by the nullishCheckStyle rule.

Examples

❌ Incorrect

if (value == 5) {
  doSomething();
}

if (name != "admin") {
  checkPermissions();
}

✅ Correct

if (value === 5) {
  doSomething();
}

if (name !== "admin") {
  checkPermissions();
}

Options

This rule has no options.

When Not To Use It

If your codebase has specific requirements for using loose equality operators in certain niche contexts, you may want to use a disable comment for those specific cases. For example, if you intentionally deal with numbers and strings interchangeably, and are accustomed to directly comparing them, this rule you might not be for you.

Related Rules

• nullishCheckStyle - Enforces consistent equality operator usage for nullish comparisons

Further Reading

• MDN: Equality comparisons and sameness
• MDN: Strict equality (===)
• MDN: Equality (==)

Equivalents in Other Linters

• Biome: noDoubleEquals
• Deno: eqeqeq
• ESLint: eqeqeq
• Oxlint: eslint/eqeqeq