no-unused-vars

Запрещает неиспользуемые переменные

Переменные, которые объявлены, но нигде не используются в коде, скорее всего, являются ошибкой, возникшей из-за незавершённого рефакторинга. Такие переменные занимают место в коде и могут сбивать читателей с толку.

Описание правила

Это правило предназначено для выявления неиспользуемых переменных, функций и параметров функций.

Переменная foo считается используемой, если выполняется хотя бы одно из следующих условий:

• Она вызывается (foo()) или создаётся (new foo())
• Её значение считывается (let bar = foo)
• Она передаётся в функцию в качестве аргумента (doSomething(foo))
• Её значение считывается внутри функции, переданной другой функции (doSomething(function() { foo(); }))

Переменная не считается используемой, если она только объявлена (let foo = 5) или ей присвоено значение (foo = 7).

Примеры неправильного кода для этого правила:

/*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"]);

Примеры правильного кода для этого правила:

/*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"]);

экспортируемые переменные

В средах, отличных от 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;

Примеры правильного кода для операции /* exported variableName */ с no-unused-vars:

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

var global_var = 42;

Параметры

Это правило принимает один аргумент — строку или объект. Строковые параметры совпадают со значениями свойства vars (описанного ниже).

По умолчанию это правило включено с параметром all для перехваченных ошибок и переменных и с параметром after-used для аргументов.

{
    "rules": {
        "no-unused-vars": ["error", {
            "vars": "all",
            "args": "after-used",
            "caughtErrors": "all",
            "ignoreRestSiblings": false,
            "ignoreUsingDeclarations": false,
            "reportUsedIgnorePattern": false
        }]
    }
}

vars

Параметр vars имеет два значения:

• "all" проверяет использование всех переменных, включая переменные в глобальной области видимости. Однако переменные, на которые распространяются другие параметры, например args и caughtErrors, не учитываются. Это значение используется по умолчанию.
• "local" позволяет не использовать переменные в глобальной области видимости.

vars: local

Примеры правильного кода с параметром { "vars": "local" }:

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

some_unused_var = 42;

Примеры правильного кода для параметра { "vars": "local" } с "languageOptions": { "sourceType": "script" }:

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

const foo = 42;

let bar;

let baz = 42;

var qux;

var quux = 42;

varsIgnorePattern

Параметр varsIgnorePattern задаёт исключения, для которых не проверяется использование: переменные, имена которых соответствуют шаблону регулярного выражения. Например, переменные, имена которых содержат ignored или Ignored. Однако переменные, на которые распространяются другие параметры, например argsIgnorePattern и caughtErrorsIgnorePattern, не учитываются.

Примеры правильного кода с параметром { "varsIgnorePattern": "[iI]gnored" }:

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

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

args

Параметр args имеет три значения:

• after-used — не проверяются неиспользуемые позиционные аргументы, расположенные перед последним используемым аргументом; все именованные аргументы и позиционные аргументы после последнего используемого аргумента проверяются.
• all — все именованные аргументы должны использоваться.
• none — не проверять аргументы.

args: after-used

Примеры неправильного кода для значения параметра { "args": "after-used" } по умолчанию:

/*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;
})();

Примеры правильного кода для значения параметра { "args": "after-used" } по умолчанию:

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

(function(foo, bar, baz, qux) {
    return qux;
})();

args: all

Примеры неправильного кода для параметра { "args": "all" }:

/*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;
})();

args: none

Примеры правильного кода для параметра { "args": "none" }:

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

(function(foo, bar, baz) {
    return bar;
})();

argsIgnorePattern

Параметр argsIgnorePattern задаёт исключения, для которых не проверяется использование: аргументы, имена которых соответствуют шаблону регулярного выражения. Например, переменные, имена которых начинаются с символа подчёркивания.

Примеры правильного кода с параметром { "argsIgnorePattern": "^_" }:

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

function foo(x, _y) {
    return x + 1;
}
foo();

caughtErrors

Параметр caughtErrors используется для проверки аргументов блока catch.

Он имеет два значения:

• all — все именованные аргументы должны использоваться. Это значение используется по умолчанию.
• none — не проверять объекты ошибок.

caughtErrors: all

Если не указывать этот параметр, он будет установлен в значение all.

Примеры неправильного кода для параметра { "caughtErrors": "all" }:

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

// 1 error
// "err" is defined but never used
try {
    //...
} catch (err) {
    console.error("errors");
}

caughtErrors: none

Примеры правильного кода для параметра { "caughtErrors": "none" }:

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

try {
    //...
} catch (err) {
    console.error("errors");
}

caughtErrorsIgnorePattern

Параметр caughtErrorsIgnorePattern задаёт исключения, для которых не проверяется использование: аргументы catch, имена которых соответствуют шаблону регулярного выражения. Например, переменные, имена которых начинаются со строки «ignore».

Примеры правильного кода с параметром { "caughtErrorsIgnorePattern": "^ignore" }:

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

try {
    //...
} catch (ignoreErr) {
    console.error("errors");
}

destructuredArrayIgnorePattern

Параметр destructuredArrayIgnorePattern задаёт исключения, для которых не проверяется использование: элементы шаблонов деструктуризации массивов, имена которых соответствуют шаблону регулярного выражения. Например, переменные, имена которых начинаются с символа подчёркивания.

Примеры правильного кода с параметром { "destructuredArrayIgnorePattern": "^_" }:

/*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;

ignoreRestSiblings

Параметр ignoreRestSiblings имеет логический тип (по умолчанию: false). С помощью свойства rest можно «исключить» свойства из объекта, но по умолчанию соседние свойства помечаются как «неиспользуемые». Если включить этот параметр, соседние свойства rest-свойства игнорируются.

Примеры правильного кода с параметром { "ignoreRestSiblings": true }:

/*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);

ignoreClassWithStaticInitBlock

Параметр ignoreClassWithStaticInitBlock имеет логический тип (по умолчанию: false). Блоки статической инициализации позволяют инициализировать статические переменные и выполнять код при вычислении определения класса, то есть код статического блока выполняется без создания нового экземпляра класса. Если установить значение true, этот параметр игнорирует классы, содержащие блоки статической инициализации.

Примеры неправильного кода для параметра { "ignoreClassWithStaticInitBlock": true }

/*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
    }
}

Примеры правильного кода для параметра { "ignoreClassWithStaticInitBlock": true }

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

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

        console.log(bar);
    }
}

ignoreUsingDeclarations

Параметр ignoreUsingDeclarations имеет логический тип (по умолчанию: false). Явное управление ресурсами позволяет автоматически освобождать ресурсы, вызывая неявно методы Symbol.dispose или Symbol.asyncDispose в конце области видимости переменной. Если для этого параметра установлено значение true, правило игнорирует переменные, объявленные с помощью using или await using.

Примеры неправильного кода для параметра { "ignoreUsingDeclarations": true }:

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

Примеры правильного кода для параметра { "ignoreUsingDeclarations": true }:

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

using syncResource = getSyncResource();
await using asyncResource = getAsyncResource();

reportUsedIgnorePattern

Параметр reportUsedIgnorePattern имеет логический тип (по умолчанию: false). При использовании этого параметра будут отмечаться переменные, соответствующие любому из допустимых параметров игнорирования шаблонов (varsIgnorePattern, argsIgnorePattern, caughtErrorsIgnorePattern или destructuredArrayIgnorePattern), если они использовались.

Примеры неправильного кода для параметра { "reportUsedIgnorePattern": true }:

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

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

Примеры правильного кода для параметра { "reportUsedIgnorePattern": true }:

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

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

Когда не следует использовать

Если вы не хотите получать уведомления о неиспользуемых переменных или аргументах функций, это правило можно отключить.

Связанные правила

• no-unassigned-vars
• no-useless-assignment

Версия

Это правило появилось в ESLint v0.0.9.

Ресурсы

• Исходный код правила
• Исходный код тестов