RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://typescript-eslint.io/rules/prefer-nullish-coalescing below:

prefer-nullish-coalescing | typescript-eslint

prefer-nullish-coalescing

Enforce using the nullish coalescing operator instead of logical assignments or chaining.

💡

Some problems reported by this rule are manually fixable by editor suggestions.

💭

This rule requires type information to run, which comes with performance tradeoffs.

The ?? nullish coalescing runtime operator allows providing a default value when dealing with null or undefined. Because the nullish coalescing operator only coalesces when the original value is null or undefined, it is much safer than relying upon logical OR operator chaining ||, which coalesces on any falsy value.

This rule reports when you may consider replacing:

An || operator with ??
An ||= operator with ??=
Ternary expressions (?:) that are equivalent to || or ?? with ??
Assignment expressions (=) that can be safely replaced by ??=

Flat Config
Legacy Config

eslint.config.mjs

export default tseslint.config({
  rules: {
    "@typescript-eslint/prefer-nullish-coalescing": "error"
  }
});

.eslintrc.cjs

module.exports = {
  "rules": {
    "@typescript-eslint/prefer-nullish-coalescing": "error"
  }
};

Try this rule in the playground ↗

Examples

❌ Incorrect
✅ Correct

declare const a: string | null;
declare const b: string | null;

const c = a || b;

declare let foo: { a: string } | null;
declare function makeFoo(): { a: string };

function lazyInitializeFooByTruthiness() {
  if (!foo) {
    foo = makeFoo();
  }
}

function lazyInitializeFooByNullCheck() {
  if (foo == null) {
    foo = makeFoo();
  }
}

Open in Playground

declare const a: string | null;
declare const b: string | null;

const c = a ?? b;

declare let foo: { a: string } | null;
declare function makeFoo(): { a: string };

function lazyInitializeFoo() {
  foo ??= makeFoo();
}

Open in Playground Options

This rule accepts the following options:

type Options = [
  {
    
    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
    
    ignoreBooleanCoercion?: boolean;
    
    ignoreConditionalTests?: boolean;
    
    ignoreIfStatements?: boolean;
    
    ignoreMixedLogicalExpressions?: boolean;
    
    ignorePrimitives?: 



    | {
          
          bigint?: boolean;
          
          boolean?: boolean;
          
          number?: boolean;
          
          string?: boolean;
        }
      
      | true;
    
    ignoreTernaryTests?: boolean;
  },
];

const defaultOptions: Options = [
  {
    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
    ignoreBooleanCoercion: false,
    ignoreConditionalTests: true,
    ignoreIfStatements: false,
    ignoreMixedLogicalExpressions: false,
    ignorePrimitives: {
      bigint: false,
      boolean: false,
      number: false,
      string: false,
    },
    ignoreTernaryTests: false,
  },
];

ignoreTernaryTests

Whether to ignore any ternary expressions that could be simplified by using the nullish coalescing operator. Default: false.

Examples of code for this rule with { ignoreTernaryTests: false }:

❌ Incorrect
✅ Correct

declare const a: any;
a !== undefined && a !== null ? a : 'a string';
a === undefined || a === null ? 'a string' : a;
a == undefined ? 'a string' : a;
a == null ? 'a string' : a;

declare const b: string | undefined;
b !== undefined ? b : 'a string';
b === undefined ? 'a string' : b;
b ? b : 'a string';
!b ? 'a string' : b;

declare const c: string | null;
c !== null ? c : 'a string';
c === null ? 'a string' : c;
c ? c : 'a string';
!c ? 'a string' : c;

Open in Playground

declare const a: any;
a ?? 'a string';

declare const b: string | undefined;
b ?? 'a string';

declare const c: string | null;
c ?? 'a string';

Open in Playground ignoreIfStatements

Whether to ignore any if statements that could be simplified by using the nullish coalescing operator. Default: false.

Examples of code for this rule with { ignoreIfStatements: false }:

❌ Incorrect
✅ Correct

declare let foo: { a: string } | null;
declare function makeFoo(): { a: string };

function lazyInitializeFoo1() {
  if (!foo) {
    foo = makeFoo();
  }
}

function lazyInitializeFoo2() {
  if (!foo) foo = makeFoo();
}

Open in Playground

declare let foo: { a: string } | null;
declare function makeFoo(): { a: string };

function lazyInitializeFoo1() {
  foo ??= makeFoo();
}

function lazyInitializeFoo2() {
  foo ??= makeFoo();
}

Open in Playground ignoreConditionalTests

Whether to ignore cases that are located within a conditional test. Default: true.

Generally expressions within conditional tests intentionally use the falsy fallthrough behavior of the logical or operator, meaning that fixing the operator to the nullish coalesce operator could cause bugs.

If you're looking to enforce stricter conditional tests, you should consider using the strict-boolean-expressions rule.

Examples of code for this rule with { ignoreConditionalTests: false }:

❌ Incorrect
✅ Correct

declare let a: string | null;
declare const b: string | null;

if (a || b) {
}
if ((a ||= b)) {
}
while (a || b) {}
while ((a ||= b)) {}
do {} while (a || b);
for (let i = 0; a || b; i += 1) {}
a || b ? true : false;

Open in Playground

declare let a: string | null;
declare const b: string | null;

if (a ?? b) {
}
if ((a ??= b)) {
}
while (a ?? b) {}
while ((a ??= b)) {}
do {} while (a ?? b);
for (let i = 0; a ?? b; i += 1) {}
(a ?? b) ? true : false;

Open in Playground ignoreMixedLogicalExpressions

Whether to ignore any logical or expressions that are part of a mixed logical expression (with &&). Default: false.

Generally expressions within mixed logical expressions intentionally use the falsy fallthrough behavior of the logical or operator, meaning that fixing the operator to the nullish coalesce operator could cause bugs.

If you're looking to enforce stricter conditional tests, you should consider using the strict-boolean-expressions rule.

Examples of code for this rule with { ignoreMixedLogicalExpressions: false }:

❌ Incorrect
✅ Correct

declare let a: string | null;
declare const b: string | null;
declare const c: string | null;
declare const d: string | null;

a || (b && c);
a ||= b && c;
(a && b) || c || d;
a || (b && c) || d;
a || (b && c && d);

Open in Playground

declare let a: string | null;
declare const b: string | null;
declare const c: string | null;
declare const d: string | null;

a ?? (b && c);
a ??= b && c;
(a && b) ?? c ?? d;
a ?? (b && c) ?? d;
a ?? (b && c && d);

Open in Playground

NOTE: Errors for this specific case will be presented as suggestions (see below), instead of fixes. This is because it is not always safe to automatically convert || to ?? within a mixed logical expression, as we cannot tell the intended precedence of the operator. Note that by design, ?? requires parentheses when used with && or || in the same expression.

ignorePrimitives

Whether to ignore all (true) or some (an object with properties) primitive types. Default: {"bigint":false,"boolean":false,"number":false,"string":false}.

If you would like to ignore expressions containing operands of certain primitive types that can be falsy then you may pass an object containing a boolean value for each primitive:

string: true, ignores null or undefined unions with string (default: false).
number: true, ignores null or undefined unions with number (default: false).
bigint: true, ignores null or undefined unions with bigint (default: false).
boolean: true, ignores null or undefined unions with boolean (default: false).

Examples of code for this rule with { ignorePrimitives: { string: false } }:

Also, if you would like to ignore all primitives types, you can set ignorePrimitives: true. It is equivalent to ignorePrimitives: { string: true, number: true, bigint: true, boolean: true }.

ignoreBooleanCoercion

Whether to ignore arguments to the Boolean constructor Default: false.

Examples of code for this rule with { ignoreBooleanCoercion: false }:

❌ Incorrect
✅ Correct

declare const a: string | true | undefined;
declare const b: string | boolean | undefined;

const x = Boolean(a || b);

Open in Playground

declare const a: string | true | undefined;
declare const b: string | boolean | undefined;

const x = Boolean(a ?? b);

Open in Playground allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing

Deprecated

This option will be removed in the next major version of typescript-eslint.

Unless this is set to true, the rule will error on every file whose tsconfig.json does not have the strictNullChecks compiler option (or strict) set to true. Default: false.

Without strictNullChecks, TypeScript essentially erases undefined and null from the types. This means when this rule inspects the types from a variable, it will not be able to tell that the variable might be null or undefined, which essentially makes this rule useless.

You should be using strictNullChecks to ensure complete type-safety in your codebase.

If for some reason you cannot turn on strictNullChecks, but still want to use this rule - you can use this option to allow it - but know that the behavior of this rule is undefined with the compiler option turned off. We will not accept bug reports if you are using this option.

When Not To Use It

If you are not using TypeScript 3.7 (or greater), then you will not be able to use this rule, as the operator is not supported.