noUnusedVariables

Diagnostic Category: lint/correctness/noUnusedVariables

JavaScript (and super languages)

Since: v1.0.0

Sources:

Same as: no-unused-vars
Same as: @typescript-eslint/no-unused-vars
Same as: unused-imports/no-unused-vars

Disallow unused variables.

There is an exception to this rule: variables that starts with underscore, e.g. let _something;.

The pattern of having an underscore as prefix of a name of variable is a very diffuse pattern among programmers, and Biome decided to follow it.

This rule won’t report unused imports. If you want to report unused imports, enable noUnusedImports.

From v1.9.0, the rule won’t check unused function parameters any more. If you want to report unused function parameters, enable noUnusedFunctionParameters.

Examples

Invalid

let a = 4;
a++;

code-block.js:1:5 lint/correctness/noUnusedVariables  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This variable is unused.
  
  > 1 │ let a = 4;
      │     ^
    2 │ a++;
    3 │ 
  
  ℹ Unused variables usually are result of incomplete refactoring, typos and other source of bugs.
  
  ℹ Unsafe fix: If this is intentional, prepend a with an underscore.
  
    1   │ - let·a·=·4;
    2   │ - a++;
      1 │ + let·_a·=·4;
      2 │ + _a++;
    3 3 │

function foo() {}

code-block.js:1:10 lint/correctness/noUnusedVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This function is unused.
  
  > 1 │ function foo() {}
      │          ^^^
    2 │ 
  
  ℹ Unused variables usually are result of incomplete refactoring, typos and other source of bugs.

export function foo(myVar) {
    console.log('foo');
}

code-block.js:1:21 lint/correctness/noUnusedVariables  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This parameter is unused.
  
  > 1 │ export function foo(myVar) {
      │                     ^^^^^
    2 │     console.log(‘foo’);
    3 │ }
  
  ℹ Unused variables usually are result of incomplete refactoring, typos and other source of bugs.
  
  ℹ Unsafe fix: If this is intentional, prepend myVar with an underscore.
  
    1   │ - export·function·foo(myVar)·{
      1 │ + export·function·foo(_myVar)·{
    2 2 │       console.log(‘foo’);
    3 3 │   }

function foo() {
    foo();
}

code-block.js:1:10 lint/correctness/noUnusedVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This function is unused.
  
  > 1 │ function foo() {
      │          ^^^
    2 │     foo();
    3 │ }
  
  ℹ Unused variables usually are result of incomplete refactoring, typos and other source of bugs.

const foo = () => {
    foo();
};

code-block.js:1:7 lint/correctness/noUnusedVariables  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This variable is unused.
  
  > 1 │ const foo = () => {
      │       ^^^
    2 │     foo();
    3 │ };
  
  ℹ Unused variables usually are result of incomplete refactoring, typos and other source of bugs.
  
  ℹ Unsafe fix: If this is intentional, prepend foo with an underscore.
  
    1   │ - const·foo·=·()·=>·{
    2   │ - ····foo();
      1 │ + const·_foo·=·()·=>·{
      2 │ + ····_foo();
    3 3 │   };
    4 4 │

export function f<T>() {}

code-block.ts:1:19 lint/correctness/noUnusedVariables  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This type parameter is unused.
  
  > 1 │ export function f<T>() {}
      │                   ^
    2 │ 
  
  ℹ Unused variables usually are result of incomplete refactoring, typos and other source of bugs.
  
  ℹ Unsafe fix: If this is intentional, prepend T with an underscore.
  
    1   │ - export·function·f<T>()·{}
      1 │ + export·function·f<_T>()·{}
    2 2 │

Valid

function foo(b) {
    console.log(b)
};
foo();

export function foo(_unused) {}

function used_overloaded(): number;
function used_overloaded(s: string): string;
function used_overloaded(s?: string) {
    return s;
}
used_overloaded();

noUnusedVariables

Examples

Invalid

Valid

Related links