one-var

强制变量在函数中一起或单独声明

可以使用 var、let 或 const 在 JavaScript 代码中的任何位置声明变量。有许多与变量声明相关的样式和偏好，其中之一就是决定在单个函数中应该允许多少个变量声明。

¥Variables can be declared at any point in JavaScript code using var, let, or const. There are many styles and preferences related to the declaration of variables, and one of those is deciding on how many variable declarations should be allowed in a single function.

在这方面有两种思想流派：

¥There are two schools of thought in this regard:

1. 函数中的所有变量都应该只有一个变量声明。该声明通常出现在函数的顶部。

   ¥There should be just one variable declaration for all variables in the function. That declaration typically appears at the top of the function.

2. 你应该为要定义的每个变量使用一个变量声明。

   ¥You should use one variable declaration for each variable you want to define.

例如：

¥For instance:

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

// multiple variable declarations per function
function foo() {
    var bar;
    var baz;
}
1
2
3
4
5
6
7
8
9
10

单一声明学派基于 ECMAScript 6 之前的行为，其中没有块作用域，只有函数作用域。由于无论如何所有 var 语句都被提升到函数的顶部，一些人认为在函数顶部的单个声明中声明所有变量可以消除范围规则的混乱。

¥The single-declaration school of thought is based in pre-ECMAScript 6 behaviors, where there was no such thing as block scope, only function scope. Since all var statements are hoisted to the top of the function anyway, some believe that declaring all variables in a single declaration at the top of the function removes confusion around scoping rules.

规则详情

¥Rule Details

此规则强制每个函数（对于 var）或块（对于 let 和 const）作用域一起或单独声明变量。

¥This rule enforces variables to be declared either together or separately per function ( for var) or block (for let and const) scope.

选项

¥Options

此规则有一个选项，可以是字符串选项或对象选项。

¥This rule has one option, which can be a string option or an object option.

字符串选项：

¥String option:

• "always"（默认）要求每个范围有一个变量声明

  ¥"always" (default) requires one variable declaration per scope

• "never" 要求每个作用域有多个变量声明

  ¥"never" requires multiple variable declarations per scope

• "consecutive" 允许每个作用域有多个变量声明，但要求将连续的变量声明合并为单个声明

  ¥"consecutive" allows multiple variable declarations per scope but requires consecutive variable declarations to be combined into a single declaration

对象选项：

¥Object option:

• "var": "always" 要求每个函数有一个 var 声明

  ¥"var": "always" requires one var declaration per function

• "var": "never" 每个函数需要多个 var 声明

  ¥"var": "never" requires multiple var declarations per function

• "var": "consecutive" 要求连续的 var 声明为单个声明

  ¥"var": "consecutive" requires consecutive var declarations to be a single declaration

• "let": "always" 要求每个块有一个 let 声明

  ¥"let": "always" requires one let declaration per block

• "let": "never" 每个块需要多个 let 声明

  ¥"let": "never" requires multiple let declarations per block

• "let": "consecutive" 要求连续的 let 声明为单个声明

  ¥"let": "consecutive" requires consecutive let declarations to be a single declaration

• "const": "always" 要求每个块有一个 const 声明

  ¥"const": "always" requires one const declaration per block

• "const": "never" 每个块需要多个 const 声明

  ¥"const": "never" requires multiple const declarations per block

• "const": "consecutive" 要求连续的 const 声明为单个声明

  ¥"const": "consecutive" requires consecutive const declarations to be a single declaration

• "separateRequires": true 强制 requires 与声明分开

  ¥"separateRequires": true enforces requires to be separate from declarations

替代对象选项：

¥Alternate object option:

• "initialized": "always" 需要为每个范围的初始化变量声明一个变量

  ¥"initialized": "always" requires one variable declaration for initialized variables per scope

• "initialized": "never" 要求每个范围的初始化变量有多个变量声明

  ¥"initialized": "never" requires multiple variable declarations for initialized variables per scope

• "initialized": "consecutive" 要求连续的变量声明才能使初始化变量成为单个声明

  ¥"initialized": "consecutive" requires consecutive variable declarations for initialized variables to be a single declaration

• "uninitialized": "always" 要求每个范围内的未初始化变量有一个变量声明

  ¥"uninitialized": "always" requires one variable declaration for uninitialized variables per scope

• "uninitialized": "never" 要求每个范围内的未初始化变量有多个变量声明

  ¥"uninitialized": "never" requires multiple variable declarations for uninitialized variables per scope

• "uninitialized": "consecutive" 要求连续的变量声明，未初始化的变量必须是单个声明

  ¥"uninitialized": "consecutive" requires consecutive variable declarations for uninitialized variables to be a single declaration

always

使用默认 "always" 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the default "always" option:

/*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;
    }
}
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
33
34
35
36
37
38
39
40
41
42

使用默认 "always" 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the default "always" option:

/*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;
        }
    }
}
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

never

使用 "never" 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the "never" option:

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

使用 "never" 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the "never" option:

/*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]);
}
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
33
34
35
36

consecutive

使用 "consecutive" 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the "consecutive" option:

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

使用 "consecutive" 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the "consecutive" option:

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

var、let、和 const

¥var, let, and const

使用 { var: "always", let: "never", const: "never" } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { var: "always", let: "never", const: "never" } option:

/*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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用 { var: "always", let: "never", const: "never" } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { var: "always", let: "never", const: "never" } option:

/*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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用 { var: "never" } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { var: "never" } option:

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

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

使用 { var: "never" } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { var: "never" } option:

/*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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

使用 { separateRequires: true } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { separateRequires: true } option:

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

var foo = require("foo"),
    bar = "bar";
1
2
3
4

使用 { separateRequires: true } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { separateRequires: true } option:

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

var foo = require("foo");
var bar = "bar";
1
2
3
4

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

var foo = require("foo"),
    bar = require("bar");
1
2
3
4

使用 { var: "never", let: "consecutive", const: "consecutive" } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { var: "never", let: "consecutive", const: "consecutive" } option:

/*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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

使用 { var: "never", let: "consecutive", const: "consecutive" } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { var: "never", let: "consecutive", const: "consecutive" } option:

/*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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用 { var: "consecutive" } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { var: "consecutive" } option:

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

function foo() {
    var a;
    var b;
}
1
2
3
4
5
6

使用 { var: "consecutive" } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { var: "consecutive" } option:

/*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;
}
1
2
3
4
5
6
7
8
9
10

initialized 和 uninitialized

¥initialized and uninitialized

使用 { "initialized": "always", "uninitialized": "never" } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { "initialized": "always", "uninitialized": "never" } option:

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

function foo() {
    var a, b, c;
    var foo = true;
    var bar = false;
}
1
2
3
4
5
6
7

使用 { "initialized": "always", "uninitialized": "never" } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { "initialized": "always", "uninitialized": "never" } option:

/*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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

使用 { "initialized": "never" } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { "initialized": "never" } option:

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

function foo() {
    var foo = true,
        bar = false;
}
1
2
3
4
5
6

使用 { "initialized": "never" } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { "initialized": "never" } option:

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

function foo() {
    var foo = true;
    var bar = false;
    var a, b, c; // Uninitialized variables are ignored
}
1
2
3
4
5
6
7

使用 { "initialized": "consecutive", "uninitialized": "never" } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { "initialized": "consecutive", "uninitialized": "never" } option:

/*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;
}
1
2
3
4
5
6
7
8
9
10

使用 { "initialized": "consecutive", "uninitialized": "never" } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { "initialized": "consecutive", "uninitialized": "never" } option:

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

function foo() {
    var a = 1,
        b = 2;
    var c;
    var d;
    var e = 3,
        f = 4;
}
1
2
3
4
5
6
7
8
9
10

使用 { "initialized": "consecutive" } 选项的此规则的错误代码示例：

¥Examples of incorrect code for this rule with the { "initialized": "consecutive" } option:

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

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

    foo();

    var c = 3;
    var d = 4;
}
1
2
3
4
5
6
7
8
9
10
11

使用 { "initialized": "consecutive" } 选项的此规则的正确代码示例：

¥Examples of correct code for this rule with the { "initialized": "consecutive" } option:

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

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

    foo();

    var c = 3,
        d = 4;
}
1
2
3
4
5
6
7
8
9
10
11

兼容性

¥Compatibility

• JSHint：此规则映射到 onevar JSHint 规则，但允许单独配置 let 和 const。

  ¥JSHint: This rule maps to the onevar JSHint rule, but allows let and const to be configured separately.

• JSCS:这条规则大致映射到 disallowMultipleVarDecl。

  ¥JSCS: This rule roughly maps to disallowMultipleVarDecl.

• JSCS:此规则选项 separateRequires 大致映射到 requireMultipleVarDecl。

  ¥JSCS: This rule option separateRequires roughly maps to requireMultipleVarDecl.

版本

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

资源

• 规则源码
• 测试源码