noUnusedVariables

此内容尚不支持你的语言。

JavaScript (and super languages)

Summary

Rule available since: v1.0.0
Diagnostic Category: lint/correctness/noUnusedVariables
This rule is recommended, which means is enabled by default.
This rule has an unsafe fix.
The default severity of this rule is warning.
Sources:
- Same as no-unused-vars
- Same as @typescript-eslint/no-unused-vars
- Same as unused-imports/no-unused-vars

How to configure

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

Description

Disallow unused variables.

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

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

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

Examples

Invalid

1
let a = 4;
2
a++;

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

  ⚠ This variable a is unused.
  
  > 1 │ let a = 4;
      │     ^
    2 │ a++;
    3 │ 
  
  ℹ Unused variables are often the result of typos, incomplete refactors, or other sources 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 │

1
function foo() {}

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

  ⚠ This function foo is unused.
  
  > 1 │ function foo() {}
      │          ^^^
    2 │ 
  
  ℹ Unused variables are often the result of typos, incomplete refactors, or other sources of bugs.
  
  ℹ Unsafe fix: If this is intentional, prepend foo with an underscore.
  
    1   │ - function·foo()·{}
      1 │ + function·_foo()·{}
    2 2 │

1
function foo() {
2
    foo();
3
}

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

  ⚠ This function foo is unused.
  
  > 1 │ function foo() {
      │          ^^^
    2 │     foo();
    3 │ }
  
  ℹ Unused variables are often the result of typos, incomplete refactors, or other sources of bugs.
  
  ℹ Unsafe fix: If this is intentional, prepend foo with an underscore.
  
    1   │ - function·foo()·{
    2   │ - ····foo();
      1 │ + function·_foo()·{
      2 │ + ····_foo();
    3 3 │   }
    4 4 │

1
const foo = () => {
2
    foo();
3
};

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

  ⚠ This variable foo is unused.
  
  > 1 │ const foo = () => {
      │       ^^^
    2 │     foo();
    3 │ };
  
  ℹ Unused variables are often the result of typos, incomplete refactors, or other sources 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 │

1
export function f<T>() {}

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

  ⚠ This type parameter T is unused.
  
  > 1 │ export function f<T>() {}
      │                   ^
    2 │ 
  
  ℹ Unused variables are often the result of typos, incomplete refactors, or other sources 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 │

1
const { brand } = car;

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

  ⚠ This variable brand is unused.
  
  > 1 │ const { brand } = car;
      │         ^^^^^
    2 │ 
  
  ℹ Unused variables are often the result of typos, incomplete refactors, or other sources of bugs.

Valid

1
function foo(b) {
2
    console.log(b)
3
};
4
foo();

1
export function foo(_unused) {}

1
function used_overloaded(): number;
2
function used_overloaded(s: string): string;
3
function used_overloaded(s?: string) {
4
    return s;
5
}
6
used_overloaded();

By default, unused variables declared inside destructured objects are ignored if the destructuring pattern also contains a rest property. (See the rule options if you want to enable these checks).

1
const car = { brand: "Tesla", year: 2019, countryCode: "US" };
2
const { brand, ...rest } = car;
3
console.log(rest);

Options

`ignoreRestSiblings`

Whether to ignore unused variables declared inside destructured objects containing rest properties (such as const { a, b, ...rest } = obj.

Default: true

Example

1
{
2
  "linter": {
3
    "rules": {
4
      "correctness": {
5
        "noUnusedVariables": {
6
          "options": {
7
            "ignoreRestSiblings": false
8
          }
9
        }
10
      }
11
    }
12
  }
13
}

1
const car = { brand: "Tesla", year: 2019, countryCode: "US" };
2
const { brand, ...other } = car;
3
console.log(other);

code-block.js:2:9 lint/correctness/noUnusedVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This variable brand is unused.
  
    1 │ const car = { brand: “Tesla”, year: 2019, countryCode: “US” };
  > 2 │ const { brand, …other } = car;
      │         ^^^^^
    3 │ console.log(other);
    4 │ 
  
  ℹ Unused variables are often the result of typos, incomplete refactors, or other sources of bugs.
  
  ℹ You can enable the ignoreRestSiblings option to ignore unused variables inside destructured objects with rest properties.

1
const car = { brand: "Tesla", year: 2019, countryCode: "US" };
2
const { brand: _, ...other } = car;
3
console.log(other);