Spec-Zone.ru › ESLint

one-var

Требует объявлять переменные вместе или по отдельности в функциях

🔧 Можно исправить автоматически

Некоторые проблемы, обнаруженные этим правилом, автоматически исправляются параметром командной строки --fix

❄️ Заморожено

В настоящее время это правило заморожено, и предложения по новым функциям не принимаются.

Переменные можно объявлять в любой точке кода JavaScript с помощью var, let, const, using или await using. Существует множество стилей и предпочтений, связанных с объявлением переменных; одно из них — выбор количества объявлений переменных, допустимых в одной функции.

На этот счет существуют два подхода:

  1. В функции должно быть только одно объявление всех переменных. Обычно оно располагается в начале функции.
  2. Для каждой переменной следует использовать отдельное объявление.

Например:

// one variable declaration per function
function foo() {
    var bar, baz;
}

// multiple variable declarations per function
function foo() {
    var bar;
    var baz;
}

Подход с одним объявлением основан на поведении до ECMAScript 6, когда блочной области видимости не существовало, а была только область видимости функции. Поскольку все инструкции var в любом случае поднимаются в начало функции, некоторые считают, что объявление всех переменных в одном объявлении в начале функции устраняет путаницу с правилами областей видимости.

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

Это правило требует объявлять переменные вместе или по отдельности в каждой функции (для var) или блоке (для let, const, using и await using) области видимости.

Параметры

У этого правила один параметр, который может быть строкой или объектом.

Строковый параметр:

  • "always" (по умолчанию) требует одно объявление переменных в каждой области видимости
  • "never" требует несколько объявлений переменных в каждой области видимости
  • "consecutive" допускает несколько объявлений переменных в каждой области видимости, но требует объединять идущие подряд объявления в одно

Объектный параметр:

  • "var": "always" требует одно объявление var в каждой функции
  • "var": "never" требует несколько объявлений var в каждой функции
  • "var": "consecutive" требует объединять идущие подряд объявления var в одно
  • "let": "always" требует одно объявление let в каждом блоке
  • "let": "never" требует несколько объявлений let в каждом блоке
  • "let": "consecutive" требует объединять идущие подряд объявления let в одно
  • "const": "always" требует одно объявление const в каждом блоке
  • "const": "never" требует несколько объявлений const в каждом блоке
  • "const": "consecutive" требует объединять идущие подряд объявления const в одно
  • "using": "always" требует одно объявление using в каждом блоке
  • "using": "never" требует несколько объявлений using в каждом блоке
  • "using": "consecutive" требует объединять идущие подряд объявления using в одно
  • "awaitUsing": "always" требует одно объявление await using в каждом блоке
  • "awaitUsing": "never" требует несколько объявлений await using в каждом блоке
  • "awaitUsing": "consecutive" требует объединять идущие подряд объявления await using в одно
  • "separateRequires": true требует отделять requires от объявлений

Альтернативный объектный параметр:

  • "initialized": "always" требует одно объявление переменных с инициализированными значениями в каждой области видимости
  • "initialized": "never" требует несколько объявлений переменных с инициализированными значениями в каждой области видимости
  • "initialized": "consecutive" требует объединять идущие подряд объявления переменных с инициализированными значениями в одно
  • "uninitialized": "always" требует одно объявление переменных без инициализированных значений в каждой области видимости
  • "uninitialized": "never" требует несколько объявлений переменных без инициализированных значений в каждой области видимости
  • "uninitialized": "consecutive" требует объединять идущие подряд объявления переменных без инициализированных значений в одно

always

Примеры неправильного кода для этого правила с параметром "always" по умолчанию:

Открыть в Playground 
/*eslint one-var: ["error", "always"]*/

function foo1() {
    var bar;
    var baz;
    let qux;
    let norf;
}

function foo2(){
    const bar = false;
    const baz = true;
    let qux;
    let norf;
}

function foo3() {
    var bar;

    if (baz) {
        var qux = true;
    }
}

class C {
    static {
        var foo;
        var bar;
    }

    static {
        var foo;
        if (bar) {
            var baz = true;
        }
    }

    static {
        let foo;
        let bar;
    }
}

Примеры правильного кода для этого правила с параметром "always" по умолчанию:

Открыть в Playground 
/*eslint one-var: ["error", "always"]*/

function foo1() {
    var bar,
        baz;
    let qux,
        norf;
}

function foo2(){
    const bar = true,
        baz = false;
    let qux,
        norf;
}

function foo3() {
    var bar,
        qux;

    if (baz) {
        qux = true;
    }
}

function foo4(){
    let bar;

    if (baz) {
        let qux;
    }
}

class C {
    static {
        var foo, bar;
    }

    static {
        var foo, baz;
        if (bar) {
            baz = true;
        }
    }

    static {
        let foo, bar;
    }

    static {
        let foo;
        if (bar) {
            let baz;
        }
    }
}

never

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

Открыть в Playground 
/*eslint one-var: ["error", "never"]*/

function foo1() {
    var bar,        baz;
    const qux =true,        foobar =false;
}

function foo2() {
    var bar,        qux;

    if (baz) {
        qux = true;
    }
}

function foo3(){
    let bar =true,        baz =false;
}

class C {
    static {
        var foo, bar;
        let baz, qux;
    }
}

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

Открыть в Playground 
/*eslint one-var: ["error", "never"]*/

function foo1() {
    var bar;
    var baz;
}

function foo2() {
    var bar;

    if (baz) {
        var qux = true;
    }
}

function foo3() {
    let bar;

    if (baz) {
        let qux = true;
    }
}

class C {
    static {
        var foo;
        var bar;
        let baz;
        let qux;
    }
}

// declarations with multiple variables are allowed in for-loop initializers
for (var i = 0, len = arr.length; i < len; i++) {
    doSomething(arr[i]);
}

consecutive

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

Открыть в Playground 
/*eslint one-var: ["error", "consecutive"]*/

function foo1() {
    var bar;
    var baz;
}

function foo2(){
    var bar = 1;
    var baz = 2;

    qux();

    var qux = 3;
    var quux;
}

class C {
    static {
        var foo;
        var bar;
        let baz;
        let qux;
    }
}

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

Открыть в Playground 
/*eslint one-var: ["error", "consecutive"]*/

function foo1() {
    var bar,
        baz;
}

function foo2(){
    var bar = 1,
        baz = 2;

    qux();

    var qux = 3,
        quux;
}

class C {
    static {
        var foo, bar;
        let baz, qux;
        doSomething();
        let quux;
        var quuux;
    }
}

var, let, const, using, and awaitUsing

Примеры неправильного кода для этого правила с параметром { var: "always", let: "never", const: "never", using: "never", awaitUsing: "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { var: "always", let: "never", const: "never", using: "never", awaitUsing: "never" }]*/

function foo1() {
    var bar;
    var baz;
    let qux,        norf;
}

function foo2() {
    const bar =1,          baz =2;
    let qux,        norf;
}

async function foo3() {
    using bar =1,          baz =2;
    await using qux =3,                norf =4;
}

Примеры правильного кода для этого правила с параметром { var: "always", let: "never", const: "never", using: "never", awaitUsing: "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { var: "always", let: "never", const: "never", using: "never", awaitUsing: "never" }]*/

function foo1() {
    var bar,
        baz;
    let qux;
    let norf;
}

function foo2() {
    const bar = 1;
    const baz = 2;
    let qux;
    let norf;
}

async function foo3() {
    using bar = 1;
    using baz = 2;
    await using qux = 3;
    await using norf = 4;
}

Примеры неправильного кода для этого правила с параметром { var: "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { var: "never" }]*/

function foo() {
    var bar,        baz;
}

Примеры правильного кода для этого правила с параметром { var: "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { var: "never" }]*/

async function foo() {
    var bar;
    var baz;

    // `const`, `let`, `using` and `await using` declarations are ignored if they are not specified
    const foobar = 1;
    const foobaz = 2;
    const barfoo = 1, bazfoo = 2;
    let qux;
    let norf;
    let fooqux, foonorf;
    using foobarfoo = 1;
    using foobazfoo = 2;
    using bazbarfoo = 1, bazfoobar = 2;
    await using foobarbaz = 1;
    await using foobazqux = 2;
    await using bazbarqux = 1, bazfooqux = 2;
}

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

Открыть в Playground 
/*eslint one-var: ["error", { separateRequires: true, var: "always" }]*/

var foo =require("foo"),    bar ="bar";

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

Открыть в Playground 
/*eslint one-var: ["error", { separateRequires: true, var: "always" }]*/

var foo = require("foo");
var bar = "bar";
Открыть в Playground 
/*eslint one-var: ["error", { separateRequires: true, var: "always" }]*/

var foo = require("foo"),
    bar = require("bar");

Примеры неправильного кода для этого правила с параметром { var: "never", let: "consecutive", const: "consecutive", using: "consecutive", awaitUsing: "consecutive" }:

Открыть в Playground 
/*eslint one-var: ["error", { var: "never", let: "consecutive", const: "consecutive", using: "consecutive", awaitUsing: "consecutive" }]*/

function foo1() {
    let a,
        b;
    let c;

    var d,        e;
}

function foo2() {
    const a = 1,
        b = 2;
    const c = 3;

    var d,        e;
}

function foo3() {
    using a = 1,
        b = 2;
    using c = 3;

    var d,        e;
}

async function foo4() {
    await using a = 1,
        b = 2;
    await using c = 3;

    var d,        e;
}

Примеры правильного кода для этого правила с параметром { var: "never", let: "consecutive", const: "consecutive", using: "consecutive", awaitUsing: "consecutive" }:

Открыть в Playground 
/*eslint one-var: ["error", { var: "never", let: "consecutive", const: "consecutive", using: "consecutive", awaitUsing: "consecutive" }]*/

function foo1() {
    let a,
        b;

    var d;
    var e;

    let f;
}

function foo2() {
    const a = 1,
          b = 2;

    var c;
    var d;

    const e = 3;
}

function foo3() {
    using a = 1,
          b = 2;

    var c;
    var d;

    using e = 3;
}

async function foo4() {
    await using a = 1,
          b = 2;

    var c;
    var d;

    await using e = 3;
}

Примеры неправильного кода для этого правила с параметром { var: "consecutive" }:

Открыть в Playground 
/*eslint one-var: ["error", { var: "consecutive" }]*/

function foo() {
    var a;
    var b;
}

Примеры правильного кода для этого правила с параметром { var: "consecutive" }:

Открыть в Playground 
/*eslint one-var: ["error", { var: "consecutive" }]*/

async function foo() {
    var a,
        b;
 
    // `const`, `let`, `using`, and `await using` declarations are ignored if they are not specified
    const c = 1;
    const d = 2;
    let e;
    let f;
    using g = 3;
    using h = 4;
    await using i = 5;
    await using j = 6;
}

инициализированные и неинициализированные

Примеры неправильного кода для этого правила с параметром { "initialized": "always", "uninitialized": "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { "initialized": "always", "uninitialized": "never" }]*/

function foo() {
    var a, b, c;
    var foo = true;
    var bar = false;
}

Примеры правильного кода для этого правила с параметром { "initialized": "always", "uninitialized": "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { "initialized": "always", "uninitialized": "never" }]*/

function foo() {
    var a;
    var b;
    var c;
    var foo = true,
        bar = false;
}

for (let z of foo) {
    doSomething(z);
}

let z;
for (z of foo) {
    doSomething(z);
}

Примеры неправильного кода для этого правила с параметром { "initialized": "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { "initialized": "never" }]*/

function foo() {
    var foo =true,        bar =false;
}

Примеры правильного кода для этого правила с параметром { "initialized": "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { "initialized": "never" }]*/

function foo() {
    var foo = true;
    var bar = false;
    var a, b, c; // Uninitialized variables are ignored
}

Примеры неправильного кода для этого правила с параметром { "initialized": "consecutive", "uninitialized": "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { "initialized": "consecutive", "uninitialized": "never" }]*/

function foo() {
    var a = 1;
    var b = 2;
    var c,        d;
    var e = 3;
    var f = 4;
}

Примеры правильного кода для этого правила с параметром { "initialized": "consecutive", "uninitialized": "never" }:

Открыть в Playground 
/*eslint one-var: ["error", { "initialized": "consecutive", "uninitialized": "never" }]*/

function foo() {
    var a = 1,
        b = 2;
    var c;
    var d;
    var e = 3,
        f = 4;
}

Примеры неправильного кода для этого правила с параметром { "initialized": "consecutive" }:

Открыть в Playground 
/*eslint one-var: ["error", { "initialized": "consecutive" }]*/

function foo() {
    var a = 1;
    var b = 2;

    foo();

    var c = 3;
    var d = 4;
}

Примеры правильного кода для этого правила с параметром { "initialized": "consecutive" }:

Открыть в Playground 
/*eslint one-var: ["error", { "initialized": "consecutive" }]*/

function foo() {
    var a = 1,
        b = 2;

    foo();

    var c = 3,
        d = 4;
}

Совместимость

  • JSHint: Это правило соответствует правилу JSHint onevar, но позволяет настраивать let и const отдельно.
  • JSCS: Это правило приблизительно соответствует правилу disallowMultipleVarDecl.
  • JSCS: Параметр правила separateRequires приблизительно соответствует правилу requireMultipleVarDecl.

Версия

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

Ресурсы

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

© OpenJS Foundation and other contributors
Licensed under the MIT License.
https://eslint.org/docs/latest/rules/one-var

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API