one-var

強制變數在函數中一起宣告或分開宣告

🔧

此規則報告的某些問題可以透過 --fix 命令列選項自動修正

❄️

此規則目前為凍結狀態，不接受功能請求。

可以使用 var、let 或 const 在 JavaScript 程式碼中的任何位置宣告變數。關於變數宣告有很多風格和偏好，其中之一是決定在單一函數中應該允許多少個變數宣告。

關於這方面有兩種思想流派

一個函數中的所有變數應該只有一個變數宣告。該宣告通常出現在函數的頂部。
您應該為每個想要定義的變數使用一個變數宣告。

例如

// 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 語句都會被提升到函數的頂部，因此有些人認為在函數頂部的單一宣告中宣告所有變數可以消除圍繞作用域規則的混淆。

規則詳情

此規則強制變數在每個函數（對於 var）或區塊（對於 let 和 const）作用域中一起宣告或分開宣告。

選項

此規則有一個選項，可以是字串選項或物件選項。

字串選項

"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 宣告為單一宣告
"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;
    }
}
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" 選項時，此規則的正確程式碼範例

在 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;
        }
    }
}
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" 選項時，此規則的錯誤程式碼範例

在 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;
    }
}
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" 選項時，此規則的正確程式碼範例

在 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]);
}
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" 選項時，此規則的錯誤程式碼範例

在 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;
    }
}
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" 選項時，此規則的正確程式碼範例

在 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;
    }
}
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: "always", let: "never", const: "never" } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

/*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" } 選項時，此規則的正確程式碼範例

在 Playground 中開啟

/*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" } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

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

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

使用 { var: "never" } 選項時，此規則的正確程式碼範例

在 Playground 中開啟

/*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 } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

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

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

使用 { separateRequires: true } 選項時，此規則的正確程式碼範例

在 Playground 中開啟

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

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

在 Playground 中開啟

/*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" } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

/*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" } 選項時，此規則的正確程式碼範例

在 Playground 中開啟

/*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" } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

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

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

使用 { var: "consecutive" } 選項時，此規則的正確程式碼範例

在 Playground 中開啟

/*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": "always", "uninitialized": "never" } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

/*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" } 選項時，此規則的正確程式碼範例

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

使用 { "initialized": "never" } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

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

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

使用 { "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
}
1
2
3
4
5
6
7

使用 { "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;
}
1
2
3
4
5
6
7
8
9
10

使用 { "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;
}
1
2
3
4
5
6
7
8
9
10

使用 { "initialized": "consecutive" } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

/*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" } 選項時，此規則的正確程式碼範例

在 Playground 中開啟

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

相容性

JSHint：此規則對應到 onevar JSHint 規則，但允許分別設定 let 和 const。
JSCS：此規則大致對應到 disallowMultipleVarDecl。
JSCS：此規則選項 separateRequires 大致對應到 requireMultipleVarDecl。

版本

此規則在 ESLint v0.0.9 中引入。

資源

編輯此頁面