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
}

code-block.ts:2:9 lint/suspicious/noUnnecessaryConditions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This condition is always truthy.
  
    1 │ function head<T>(items: T[]) {
  > 2 │     if (items) {
      │         ^^^^^
    3 │         return items[0];
    4 │     }
  
  ℹ The value’s type can never be falsy, so this check is redundant.

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

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

code-block.ts:2:9 lint/suspicious/noUnnecessaryConditions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This condition is always truthy.
  
    1 │ function foo(arg: ‘bar’ | ‘baz’) {
  > 2 │     if (arg) {}
      │         ^^^
    3 │ }
    4 │ 
  
  ℹ The value’s type can never be falsy, so this check is redundant.

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

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

code-block.ts:2:12 lint/suspicious/noUnnecessaryConditions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Unnecessary optional chaining.
  
    1 │ function bar(arg: string) {
  > 2 │     return arg?.length;
      │            ^^^
    3 │ }
    4 │ 
  
  ℹ Replace ?. with ..
  
    1 │ function bar(arg: string) {
  > 2 │     return arg?.length;
      │               ^^
    3 │ }
    4 │ 
  
  ℹ The receiver is guaranteed to be non-nullish.

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

code-block.ts:2:12 lint/suspicious/noUnnecessaryConditions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Unnecessary nullish coalescing.
  
    1 │ function withDefault(name: string) {
  > 2 │     return name ?? “anonymous”;
      │            ^^^^
    3 │ }
    4 │ 
  
  ℹ Drop ?? and the fallback expression.
  
    1 │ function withDefault(name: string) {
  > 2 │     return name ?? “anonymous”;
      │                 ^^
    3 │ }
    4 │ 
  
  ℹ The left-hand side is guaranteed to be non-nullish, so the fallback is unreachable.

|| and && on always-truthy operands:

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

code-block.ts:3:12 lint/suspicious/noUnnecessaryConditions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This condition is always truthy.
  
    1 │ interface Config { items: string[] }
    2 │ function f(c: Config) {
  > 3 │     return c.items || [];
      │            ^^^^^^^
    4 │ }
    5 │ 
  
  ℹ The value’s type can never be falsy, so this check is redundant.

!expr on a value that is always truthy:

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

code-block.ts:2:5 lint/suspicious/noUnnecessaryConditions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This condition is always falsy.
  
    1 │ const items = [];
  > 2 │ if (!items) {}
      │     ^^^^^^
    3 │ 
  
  ℹ The value’s type can never be truthy, so this check is redundant.

Comparing a non-nullable value against null or undefined:

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

code-block.ts:2:12 lint/suspicious/noUnnecessaryConditions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This comparison always has the same result.
  
    1 │ function f(x: string) {
  > 2 │     return x === null;
      │            ^^^^^^^^^^
    3 │ }
    4 │ 
  
  ℹ The operands’ types make the outcome statically known.

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
}

code-block.ts:3:14 lint/suspicious/noUnnecessaryConditions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This case is unreachable.
  
    1 │ function f(v: ‘a’ | ‘b’) {
    2 │     switch (v) {
  > 3 │         case ‘c’: return 1;
      │              ^^^
    4 │     }
    5 │ }
  
  ℹ The value passed to switch can never equal this value.

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) {}