useNullishCoalescing

JavaScript (and super languages)

Summary

Rule available since: v2.4.5
Diagnostic Category: lint/nursery/useNullishCoalescing
This rule has a safe fix.
The default severity of this rule is information.
This rule belongs to the following domains:
- types
Sources:
- Inspired from @typescript-eslint/prefer-nullish-coalescing

How to configure

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

Description

Enforce using the nullish coalescing operator (??) instead of logical or (||).

The ?? operator only checks for null and undefined, while || checks for any falsy value including 0, '', and false. This can prevent bugs where legitimate falsy values are incorrectly treated as missing.

For || expressions, this rule triggers when the left operand is possibly nullish (contains null or undefined in its type). A safe fix is only offered when type analysis confirms the left operand can only be truthy or nullish (not other falsy values like 0 or '').

For ||= assignment expressions, the same logic applies: a ||= b is flagged when a is possibly nullish and can be rewritten as a ??= b.

For ternary expressions, this rule detects patterns like x !== null ? x : y and suggests rewriting them as x ?? y. This applies to strict and loose equality checks against null or undefined, including compound checks.

By default, || expressions in conditional test positions (if/while/for/ternary) are ignored, as the falsy-checking behavior is often intentional there. This can be disabled with the ignoreConditionalTests option.

Examples

Invalid

1
declare const maybeString: string | null;
2
const value = maybeString || 'default'; // should use ??

1
declare const maybeNumber: number | undefined;
2
const value = maybeNumber || 0; // should use ??

1
declare let x: string | null;
2
x ||= 'default'; // should use ??=

1
declare const x: string | null;
2
const value = x !== null ? x : 'default'; // should use ??

code-block.ts:2:15 lint/nursery/useNullishCoalescing  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Prefer ?? over a ternary expression checking for nullish.
  
    1 │ declare const x: string | null;
  > 2 │ const value = x !== null ? x : ‘default’; // should use ??
      │               ^^^^^^^^^^
    3 │ 
  
  ℹ This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/8043 for more information or to report possible bugs.
  
  ℹ This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
  
  ℹ Safe fix: Use ?? instead.
  
    1 1 │   declare const x: string | null;
    2   │ - const·value·=·x·!==·null·?·x·:·‘default’;·//·should·use·??
      2 │ + const·value·=·x·??·‘default’;·//·should·use·??
    3 3 │

1
declare const x: string | null;
2
const value = x == null ? 'default' : x; // should use ??

code-block.ts:2:15 lint/nursery/useNullishCoalescing  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Prefer ?? over a ternary expression checking for nullish.
  
    1 │ declare const x: string | null;
  > 2 │ const value = x == null ? ‘default’ : x; // should use ??
      │               ^^^^^^^^^
    3 │ 
  
  ℹ This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/8043 for more information or to report possible bugs.
  
  ℹ This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
  
  ℹ Safe fix: Use ?? instead.
  
    1 1 │   declare const x: string | null;
    2   │ - const·value·=·x·==·null·?·‘default’·:·x;·//·should·use·??
      2 │ + const·value·=·x·??·‘default’;·//·should·use·??
    3 3 │

Valid

1
// Already using ??
2
declare const maybeString: string | null;
3
const value = maybeString ?? 'default';

1
// Type is not nullish - no null or undefined in union
2
declare const definiteString: string;
3
const value = definiteString || 'fallback';

1
// In conditional test position (ignored by default)
2
declare const cond: string | null;
3
if (cond || 'fallback') {
4
  console.log('in if');
5
}

1
// Already using ??=
2
declare let y: string | null;
3
y ??= 'default';

Options

ignoreConditionalTests

Ignore || expressions inside conditional test positions (if/while/for/do-while/ternary conditions), where falsy-checking behavior may be intentional.

Default: true

Setting this to false will report || in conditional tests:

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "useNullishCoalescing": {
6
          "options": {
7
            "ignoreConditionalTests": false
8
          }
9
        }
10
      }
11
    }
12
  }
13
}

1
declare const cond: string | null;
2
if (cond || 'fallback') {}

ignoreTernaryTests

Ignore ternary expressions that check for null or undefined and could be replaced with ??.

Default: false

Setting this to true will suppress ternary diagnostics:

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "useNullishCoalescing": {
6
          "options": {
7
            "ignoreTernaryTests": true
8
          }
9
        }
10
      }
11
    }
12
  }
13
}

1
declare const x: string | null;
2
const value = x !== null ? x : 'default'; // no diagnostic