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

Description

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.

Options

The rule supports the following options:

1
{
2
  "options": {
3
    "ignoreRestSiblings": true
4
  }
5
}

ignoreRestSiblings: Whether to ignore unused variables from an object destructuring with a spread (i.e.: whether a and b in const { a, b, ...rest } = obj should be ignored by this rule). Defaults to false.

Examples

Invalid

1
let a = 4;
2
a++;

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

  ⚠ This variable is unused.
  
  > 1 │ let a = 4;
      │     ^
    2 │ a++;
    3 │ 
  
  ℹ Unused variables are often the result of an incomplete refactoring, typos, 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 is unused.
  
  > 1 │ function foo() {}
      │          ^^^
    2 │ 
  
  ℹ Unused variables are often the result of an incomplete refactoring, typos, 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 is unused.
  
  > 1 │ function foo() {
      │          ^^^
    2 │     foo();
    3 │ }
  
  ℹ Unused variables are often the result of an incomplete refactoring, typos, 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 is unused.
  
  > 1 │ const foo = () => {
      │       ^^^
    2 │     foo();
    3 │ };
  
  ℹ Unused variables are often the result of an incomplete refactoring, typos, 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 is unused.
  
  > 1 │ export function f<T>() {}
      │                   ^
    2 │ 
  
  ℹ Unused variables are often the result of an incomplete refactoring, typos, 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
// With `ignoreRestSiblings: false`
2
const car = { brand: "Tesla", year: 2019, countryCode: "US" };
3
const { brand, ...other } = car;
4
console.log(other);

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

  ⚠ This variable is unused.
  
    1 │ // With ignoreRestSiblings: false
    2 │ const car = { brand: “Tesla”, year: 2019, countryCode: “US” };
  > 3 │ const { brand, …other } = car;
      │         ^^^^^
    4 │ console.log(other);
    5 │ 
  
  ℹ Unused variables are often the result of an incomplete refactoring, typos, or other sources of bugs.
  
  ℹ You can use the ‘ignoreRestSiblings’ option to ignore unused variables in an object destructuring with a spread.

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();

1
// With `ignoreRestSiblings: false`
2
const car = { brand: "Tesla", year: 2019, countryCode: "US" };
3
const { brand: _brand, ...other } = car;
4
console.log(other);

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

How to configure

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