one-var

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

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

В этом вопросе существуют две точки зрения:

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).

Параметры

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

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

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

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

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

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

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

always

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

/*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" по умолчанию:

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

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

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

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

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

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

/*eslint one-var: ["error", { var: "always", let: "never", const: "never" }]*/

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

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

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

/*eslint one-var: ["error", { var: "always", let: "never", const: "never" }]*/

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

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

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

/*eslint one-var: ["error", { var: "never" }]*/

function foo() {
    var bar,        baz;
}

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

/*eslint one-var: ["error", { var: "never" }]*/

function foo() {
    var bar;
    var baz;

    // `const` and `let` 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;
}

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

/*eslint one-var: ["error", { separateRequires: true, var: "always" }]*/

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

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

/*eslint one-var: ["error", { separateRequires: true, var: "always" }]*/

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

/*eslint one-var: ["error", { separateRequires: true, var: "always" }]*/

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

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

/*eslint one-var: ["error", { var: "never", let: "consecutive", const: "consecutive" }]*/

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

    var d,        e;
}

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

    var d,        e;
}

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

/*eslint one-var: ["error", { var: "never", let: "consecutive", const: "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;
}

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

/*eslint one-var: ["error", { var: "consecutive" }]*/

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

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

/*eslint one-var: ["error", { var: "consecutive" }]*/

function foo() {
    var a,
        b;
    const c = 1; // `const` and `let` declarations are ignored if they are not specified
    const d = 2;
    let e;
    let f;
}

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

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

/*eslint one-var: ["error", { "initialized": "always", "uninitialized": "never" }]*/

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

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

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

/*eslint one-var: ["error", { "initialized": "never" }]*/

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

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

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

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

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

/*eslint one-var: ["error", { "initialized": "consecutive" }]*/

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

    foo();

    var c = 3;
    var d = 4;
}

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

/*eslint one-var: ["error", { "initialized": "consecutive" }]*/

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

    foo();

    var c = 3,
        d = 4;
}

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

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

Версия

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

Ресурсы

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