no-unused-vars

禁止未使用的变量

✅

使用 recommended 配置从 @eslint/js 在配置文件中启用此规则

💡

此规则报告的一些问题可以通过编辑器建议手动修复

在代码中声明但未在任何地方使用的变量极可能是由于重构不彻底导致的错误。此类变量会占用代码空间，并可能导致读者困惑。

规则详情

本规则旨在消除未使用的变量、函数和函数参数。

如果满足以下任一条件，则认为变量 foo 已被使用：

它被调用 (foo()) 或被构造 (new foo())
它被读取 (let bar = foo)
它作为参数传递给函数 (doSomething(foo))
它在传递给另一个函数的函数内部被读取 (doSomething(function() { foo(); }))

如果一个变量仅被声明 (let foo = 5) 或被赋值 (foo = 7)，则该变量不被视为已使用。

此规则的错误代码示例

在 Playground 中打开

/*eslint no-unused-vars: "error"*/
/*global some_unused_var*/

// It checks variables you have defined as global
some_unused_var = 42;

let x;

// Write-only variables are not considered as used.
let y = 10;
y = 5;

// A read for a modification of itself is not considered as used.
let z = 0;
z = z + 1;

// By default, unused arguments cause warnings.
(function(foo) {
    return 5;
})();

// Unused recursive functions also cause warnings.
function fact(n) {
    if (n < 2) return 1;
    return n * fact(n - 1);
}

// When a function definition destructures an array, unused entries from the array also cause warnings.
function getY([x, y]) {
    return y;
}
getY(["a", "b"]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

此规则的正确代码示例

在 Playground 中打开

/*eslint no-unused-vars: "error"*/

const x = 10;
alert(x);

// foo is considered used here
myFunc(function foo() {
    // ...
}.bind(this));

(function(foo) {
    return foo;
})();

var myFunc;
myFunc = setTimeout(function() {
    // myFunc is considered used
    myFunc();
}, 50);

// Only the second argument from the destructured array is used.
function getY([, y]) {
    return y;
}
getY(["a", "b"]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

exported

在 CommonJS 或 ECMAScript 模块之外的环境中，你可以使用 var 创建一个可能被其他脚本使用的全局变量。你可以使用 /* exported variableName */ 注释块来指示该变量正在被导出，因此不应被视为未使用。

请注意，/* exported */ 对以下任何情况均无效：

当 languageOptions.sourceType 为 module（默认值）或 commonjs 时
当 languageOptions.parserOptions.ecmaFeatures.globalReturn 为 true 时

行注释 // exported variableName 不起作用，因为 exported 不是针对特定行的。

/* exported global_var */

var global_var = 42;
1
2
3

no-unused-vars 配合 /* exported variableName */ 操作的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: "error"*/
/* exported global_var */

var global_var = 42;
1
2
3
4

选项

此规则接受一个参数，可以是字符串或对象。字符串设置与 vars 属性的设置相同（详见下文）。

默认情况下，此规则对捕获的错误 (caught errors) 和变量启用 all 选项，对参数启用 after-used 选项。

{
    "rules": {
        "no-unused-vars": ["error", {
            "vars": "all",
            "args": "after-used",
            "caughtErrors": "all",
            "ignoreRestSiblings": false,
            "ignoreUsingDeclarations": false,
            "reportUsedIgnorePattern": false
        }]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

vars

vars 选项有两个设置：

"all" 检查所有变量的使用情况，包括全局作用域内的变量。但是，它会排除 args 和 caughtErrors 等其他选项所针对的变量。这是默认设置。
"local" 允许全局作用域内的变量不被使用。

vars: local

{ "vars": "local" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "vars": "local" }]*/
/*global some_unused_var */

some_unused_var = 42;
1
2
3
4

带有 "languageOptions": { "sourceType": "script" } 的 { "vars": "local" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "vars": "local" }]*/

const foo = 42;

let bar;

let baz = 42;

var qux;

var quux = 42;
1
2
3
4
5
6
7
8
9
10
11

varsIgnorePattern

varsIgnorePattern 选项指定了不检查使用情况的例外：名称匹配正则表达式模式的变量。例如，名称包含 ignored 或 Ignored 的变量。但是，它会排除 argsIgnorePattern 和 caughtErrorsIgnorePattern 等其他选项所针对的变量。

{ "varsIgnorePattern": "[iI]gnored" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "varsIgnorePattern": "[iI]gnored" }]*/

const firstVarIgnored = 1;
const secondVar = 2;
console.log(secondVar);
1
2
3
4
5

args

args 选项有三个设置：

after-used - 最后一个使用的参数之前的未使用位置参数将不被检查，但所有命名参数以及最后一个使用的参数之后的所有位置参数都将被检查。
all - 所有命名参数都必须被使用。
none - 不检查参数。

args: after-used

默认 { "args": "after-used" } 选项的错误代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "args": "after-used" }]*/

// 2 errors, for the parameters after the last used parameter (bar)
// "baz" is defined but never used
// "qux" is defined but never used
(function(foo, bar, baz, qux) {
    return bar;
})();
1
2
3
4
5
6
7
8

默认 { "args": "after-used" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", {"args": "after-used"}]*/

(function(foo, bar, baz, qux) {
    return qux;
})();
1
2
3
4
5

args: all

{ "args": "all" } 选项的错误代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "args": "all" }]*/

// 2 errors
// "foo" is defined but never used
// "baz" is defined but never used
(function(foo, bar, baz) {
    return bar;
})();
1
2
3
4
5
6
7
8

args: none

{ "args": "none" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "args": "none" }]*/

(function(foo, bar, baz) {
    return bar;
})();
1
2
3
4
5

argsIgnorePattern

argsIgnorePattern 选项指定了不检查使用情况的例外：名称匹配正则表达式模式的参数。例如，以下划线开头的变量。

{ "argsIgnorePattern": "^_" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }]*/

function foo(x, _y) {
    return x + 1;
}
foo();
1
2
3
4
5
6

caughtErrors

caughtErrors 选项用于 catch 块参数的验证。

它有两个设置：

all - 所有命名参数都必须被使用。这是默认设置。
none - 不检查错误对象。

caughtErrors: all

不指定此选项等同于将其设置为 all。

{ "caughtErrors": "all" } 选项的错误代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "caughtErrors": "all" }]*/

// 1 error
// "err" is defined but never used
try {
    //...
} catch (err) {
    console.error("errors");
}
1
2
3
4
5
6
7
8
9

caughtErrors: none

{ "caughtErrors": "none" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "caughtErrors": "none" }]*/

try {
    //...
} catch (err) {
    console.error("errors");
}
1
2
3
4
5
6
7

caughtErrorsIgnorePattern

caughtErrorsIgnorePattern 选项指定了不检查使用情况的例外：名称匹配正则表达式模式的 catch 参数。例如，名称以字符串 ‘ignore’ 开头的变量。

{ "caughtErrorsIgnorePattern": "^ignore" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "caughtErrors": "all", "caughtErrorsIgnorePattern": "^ignore" }]*/

try {
    //...
} catch (ignoreErr) {
    console.error("errors");
}
1
2
3
4
5
6
7

destructuredArrayIgnorePattern

destructuredArrayIgnorePattern 选项指定了不检查使用情况的例外：数组解构模式中名称匹配正则表达式模式的元素。例如，名称以下划线开头的变量。

{ "destructuredArrayIgnorePattern": "^_" } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "destructuredArrayIgnorePattern": "^_" }]*/

const [a, _b, c] = ["a", "b", "c"];
console.log(a+c);

const { x: [_a, foo] } = bar;
console.log(foo);

function baz([_c, x]) {
    x;
}
baz();

function test({p: [_q, r]}) {
    r;
}
test();

let _m, n;
foo.forEach(item => {
    [_m, n] = item;
    console.log(n);
});

let _o, p;
_o = 1;
[_o, p] = foo;
p;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

ignoreRestSiblings

ignoreRestSiblings 选项是一个布尔值（默认为 false）。使用 Rest 属性可以从对象中“忽略”某些属性，但默认情况下，兄弟属性会被标记为“未使用”。启用此选项后，Rest 属性的兄弟属性将被忽略。

{ "ignoreRestSiblings": true } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "ignoreRestSiblings": true }]*/

// 'foo' and 'bar' were ignored because they have a rest property sibling.
const { foo, ...rest } = data;
console.log(rest);

// OR

let bar;
({ bar, ...rest } = data);
1
2
3
4
5
6
7
8
9
10

ignoreClassWithStaticInitBlock

ignoreClassWithStaticInitBlock 选项是一个布尔值（默认为 false）。静态初始化块允许你在评估类定义期间初始化静态变量并执行代码，这意味着静态块代码在不创建类的新实例的情况下执行。当设置为 true 时，此选项将忽略包含静态初始化块的类。

{ "ignoreClassWithStaticInitBlock": true } 选项的错误代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "ignoreClassWithStaticInitBlock": true }]*/

class Foo {
    static myProperty = "some string";
    static mymethod() {
        return "some string";
    }
}

class Bar {
    static {
        let baz; // unused variable
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

{ "ignoreClassWithStaticInitBlock": true } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "ignoreClassWithStaticInitBlock": true }]*/

class Foo {
    static {
        let bar = "some string";

        console.log(bar);
    }
}
1
2
3
4
5
6
7
8
9

ignoreUsingDeclarations

ignoreUsingDeclarations 选项是一个布尔值（默认为 false）。显式资源管理允许通过在变量作用域结束时隐式调用 Symbol.dispose 或 Symbol.asyncDispose 方法来自动拆卸可释放资源。当此选项设置为 true 时，此规则将忽略使用 using 或 await using 声明的变量。

{ "ignoreUsingDeclarations": true } 选项的错误代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "ignoreUsingDeclarations": true }]*/
const resource = getResource();
1
2

{ "ignoreUsingDeclarations": true } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "ignoreUsingDeclarations": true }]*/

using syncResource = getSyncResource();
await using asyncResource = getAsyncResource();
1
2
3
4

reportUsedIgnorePattern

reportUsedIgnorePattern 选项是一个布尔值（默认为 false）。使用此选项后，如果匹配任何有效忽略模式选项（varsIgnorePattern、argsIgnorePattern、caughtErrorsIgnorePattern 或 destructuredArrayIgnorePattern）的变量已被使用，规则将对其进行报告。

{ "reportUsedIgnorePattern": true } 选项的错误代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "reportUsedIgnorePattern": true, "varsIgnorePattern": "[iI]gnored" }]*/

const firstVarIgnored = 1;
const secondVar = 2;
console.log(firstVarIgnored, secondVar);
1
2
3
4
5

{ "reportUsedIgnorePattern": true } 选项的正确代码示例：

在 Playground 中打开

/*eslint no-unused-vars: ["error", { "reportUsedIgnorePattern": true, "varsIgnorePattern": "[iI]gnored" }]*/

const firstVar = 1;
const secondVar = 2;
console.log(firstVar, secondVar);
1
2
3
4
5

何时不使用它

如果你不想收到关于未使用变量或函数参数的通知，可以放心地关闭此规则。

版本

此规则是在 ESLint v0.0.9 中引入的。

资源

编辑此页

no-unused-vars

规则详情

exported

选项

vars

vars: local

varsIgnorePattern

args

args: after-used

args: all

args: none

argsIgnorePattern

caughtErrors

caughtErrors: all

caughtErrors: none

caughtErrorsIgnorePattern

destructuredArrayIgnorePattern

ignoreRestSiblings

ignoreClassWithStaticInitBlock

ignoreUsingDeclarations

reportUsedIgnorePattern

何时不使用它

相关规则

版本

资源