Pular para o conteúdo
Biome
Docs Playground
Blog

noUnusedVariables

Este conteúdo não está disponível em sua língua ainda.

Diagnostic Category: lint/correctness/noUnusedVariables

Since: v1.0.0

Sources:

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

Section titled Examples

Invalid

Section titled 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

Section titled 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();
Section titled Related links