noUnusedFunctionParameters (JavaScript)

Language JavaScript (and super languages)

Summary

Rule available since: v1.8.0
Diagnostic Category: lint/correctness/noUnusedFunctionParameters
This rule is recommended, meaning it is enabled by default.
This rule has an unsafe fix.
The default severity of this rule is warning.

How to configure

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

Description

Disallow unused function parameters.

There is an exception to this rule: parameters that starts with underscore, e.g. function foo(_a, _b) {}.

Examples

Invalid

1
function foo(myVar) {
2
    console.log('foo');
3
}

code-block.js:1:14 lint/correctness/noUnusedFunctionParameters  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This parameter myVar is unused.
  
  > 1 │ function foo(myVar) {
      │              ^^^^^
    2 │     console.log('foo');
    3 │ }
  
  ℹ Unused parameters might be the result of an incomplete refactoring.
  
  ℹ Unsafe fix: If this is intentional, prepend myVar with an underscore.
  
    1   │ - function·foo(myVar)·{
      1 │ + function·foo(_myVar)·{
    2 2 │       console.log('foo');
    3 3 │   }

1
new Promise((accept, reject) => {
2
    window.setTimeout(accept, 1000);
3
});

code-block.js:1:22 lint/correctness/noUnusedFunctionParameters  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This parameter reject is unused.
  
  > 1 │ new Promise((accept, reject) => {
      │                      ^^^^^^
    2 │     window.setTimeout(accept, 1000);
    3 │ });
  
  ℹ Unused parameters might be the result of an incomplete refactoring.
  
  ℹ Unsafe fix: If this is intentional, prepend reject with an underscore.
  
    1   │ - new·Promise((accept,·reject)·=>·{
      1 │ + new·Promise((accept,·_reject)·=>·{
    2 2 │       window.setTimeout(accept, 1000);
    3 3 │   });

1
const squares = [[1, 1], [2, 4], [3, 9], [4, 16]];
2
squares.filter(([k, v]) => v > 5);

code-block.js:2:18 lint/correctness/noUnusedFunctionParameters  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This parameter k is unused.
  
    1 │ const squares = [[1, 1], [2, 4], [3, 9], [4, 16]];
  > 2 │ squares.filter(([k, v]) => v > 5);
      │                  ^
    3 │ 
  
  ℹ Unused parameters might be the result of an incomplete refactoring.
  
  ℹ Unsafe fix: If this is intentional, prepend k with an underscore.
  
    1 1 │   const squares = [[1, 1], [2, 4], [3, 9], [4, 16]];
    2   │ - squares.filter(([k,·v])·=>·v·>·5);
      2 │ + squares.filter(([_k,·v])·=>·v·>·5);
    3 3 │

Valid

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

1
function withObjectSpread({ a, ...rest }) {
2
       return rest;
3
}

Options

The rule has the following options

`ignoreRestSiblings`

Since v2.1.0

Whether to ignore unused variables from an object destructuring with a spread. Example: a and b in function({ a, b, ...rest }) { return rest;} should be ignored by this rule when set to false.

Defaults to true.

1
{
2
  "linter": {
3
    "rules": {
4
      "correctness": {
5
        "noUnusedFunctionParameters": {
6
          "level": "on",
7
          "options": {
8
            "ignoreRestSiblings": false
9
          }
10
        }
11
      }
12
    }
13
  }
14
}

1
function withObjectSpread({ b, ...rest }) {
2
       return rest;
3
}

code-block.js:1:29 lint/correctness/noUnusedFunctionParameters ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ This parameter b is unused.
  
  > 1 │ function withObjectSpread({ b, ...rest }) {
      │                             ^
    2 │        return rest;
    3 │ }
  
  ℹ Unused parameters might be the result of an incomplete refactoring.