no-unused-vars

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

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

Подробное описание правила

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

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

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

Переменная не считается используемой, если она только объявляется (var 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;

var x;

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

// A read for a modification of itself is not considered as used.
var 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"*/

var 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 */ не влияет ни на одно из следующих условий:

• когда среда node или commonjs
• когда parserOptions.sourceType равно module
• когда 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,
            "reportUsedIgnorePattern": false
        }]
    }
}

переменные

Настройка vars имеет два значения:

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

переменные: локальные

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

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

some_unused_var = 42;

varsIgnorePattern

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

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

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

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

аргументы

Настройка args имеет три значения:

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

аргументы: после использованного

Примеры неправильного кода для настройки по умолчанию { "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" }:

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

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

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

argsIgnorePattern

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

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

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

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

caughtErrors

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

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

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

caughtErrors: все

Отсутствие этой настройки эквивалентно её присвоению значению 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, имена которых соответствуют шаблону regexp. Например, переменные, имена которых начинаются с строки ‘ignore’.

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

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

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

destructuredArrayIgnorePattern

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

Примеры правильного кода для опции { "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 Property, можно «опустить» свойства из объекта, но по умолчанию свойства-соседи помечаются как «неиспользуемые». При включении этой опции свойства-соседи rest свойства игнорируются.

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

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

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

// OR

var 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);
    }
}

reportUsedIgnorePattern

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

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

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

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

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

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

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

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

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

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

• no-useless-assignment

Версия

Это правило было добавлено в ESLint v0.0.9.

Ресурсы

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