noUnnecessaryConditions

JavaScript (and super languages)

Summary

Rule available since: v2.1.4
Diagnostic Category: lint/suspicious/noUnnecessaryConditions
This rule isn’t recommended, so you need to enable it.
This rule doesn’t have a fix.
The default severity of this rule is warning.
This rule belongs to the following domains:
- types
Sources:
- Inspired from @typescript-eslint/no-unnecessary-condition

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "suspicious": {
5
        "noUnnecessaryConditions": "error"
6
      }
7
    }
8
  }
9
}

Description

Disallow conditions that always evaluate to the same value.

Using type information, this rule reports conditions whose result is statically known. It covers if/while/for/ternary tests, the ?? and ||/&& operators, optional chaining (?.), comparisons against null/undefined, and case clauses that can never match the value passed to switch.

Examples

Invalid

A non-nullable value never needs an if guard:

1
function head<T>(items: T[]) {
2
    if (items) {
3
        return items[0];
4
    }
5
}

A literal-union type can never be empty, so the truthiness check is redundant:

1
function foo(arg: 'bar' | 'baz') {
2
    if (arg) {}
3
}

?. and ?? on operands that are guaranteed to be non-nullish:

1
function bar(arg: string) {
2
    return arg?.length;
3
}

1
function withDefault(name: string) {
2
    return name ?? "anonymous";
3
}

|| and && on always-truthy operands:

1
interface Config { items: string[] }
2
function f(c: Config) {
3
    return c.items || [];
4
}

!expr on a value that is always truthy:

1
const items = [];
2
if (!items) {}

Comparing a non-nullable value against null or undefined:

1
function f(x: string) {
2
    return x === null;
3
}

A case whose value can never equal the value passed to switch:

1
function f(v: 'a' | 'b') {
2
    switch (v) {
3
        case 'c': return 1;
4
    }
5
}

Valid

When the type allows nullish or empty values, the check is meaningful. The rule also does not report bindings that are reassigned to values of different truthiness, since their narrowing cannot be inferred reliably.

1
function head<T>(items: T[] | null) {
2
    if (items) {
3
        return items[0];
4
    }
5
}
6

7
function bar(arg: string | undefined) {
8
    return arg?.length;
9
}
10

11
function f(v: 'a' | 'b' | 'c') {
12
    switch (v) {
13
        case 'a': break;
14
        case 'b': break;
15
        case 'c': break;
16
    }
17
}
18

19
let greeting = false;
20
function update() { greeting = "Hello"; }
21
if (greeting) {}