object-curly-newline

強制在開括號後和閉括號前保持一致的換行符

🔧

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

重要

此規則已在 ESLint v8.53.0 中棄用。請使用 @stylistic/eslint-plugin-js 中的對應規則。

瞭解更多

許多風格指南要求或禁止在物件大括號和其他符號內換行。

規則詳情

此規則要求或禁止在物件字面值或解構賦值中的 { 和其後面的符號之間，以及 } 和其前面的符號之間換行。

選項

此規則有一個字串選項

"always" 要求在開括號後和閉括號前換行
"never" 禁止在開括號後和閉括號前換行

或一個物件選項

"multiline": true 要求如果屬性內部或屬性之間有換行符，則換行。否則，禁止換行。
"minProperties" 要求如果屬性數量至少為給定的整數，則換行。預設情況下，如果物件包含換行符且屬性數量少於給定的整數，也會報告錯誤。但是，如果將 consistent 選項設定為 true，則會停用第二個行為
"consistent": true (預設) 要求大括號要嘛都直接包圍換行符，要嘛都不包圍。請注意，啟用此選項也會變更 minProperties 選項的行為。（請參閱上面的 minProperties 以取得更多資訊）

您可以為物件字面值、解構賦值以及具名匯入和匯出指定不同的選項

{
    "object-curly-newline": ["error", {
        "ObjectExpression": "always",
        "ObjectPattern": { "multiline": true },
        "ImportDeclaration": "never",
        "ExportDeclaration": { "multiline": true, "minProperties": 3 }
    }]
}
1
2
3
4
5
6
7
8

"ObjectExpression" 物件字面值的設定
"ObjectPattern" 解構賦值的物件模式的設定
"ImportDeclaration" 具名匯入的設定
"ExportDeclaration" 具名匯出的設定

always

使用 "always" 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

/*eslint object-curly-newline: ["error", "always"]*/

let a = {};
let b = {foo: 1};
let c = {foo: 1, bar: 2};
let d = {foo: 1,
    bar: 2};
let e = {foo() {
    dosomething();
}};

let {} = obj;
let {f} = obj;
let {g, h} = obj;
let {i,
    j} = obj;
let {k = function() {
    dosomething();
}} = obj;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

使用 "always" 選項時，此規則的正確程式碼範例

在 Playground 中開啟

/*eslint object-curly-newline: ["error", "always"]*/

let a = {
};
let b = {
    foo: 1
};
let c = {
    foo: 1, bar: 2
};
let d = {
    foo: 1,
    bar: 2
};
let e = {
    foo: function() {
        dosomething();
    }
};

let {
} = obj;
let {
    f
} = obj;
let {
    g, h
} = obj;
let {
    i,
    j
} = obj;
let {
    k = function() {
        dosomething();
    }
} = obj;
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

never

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", "never"]*/

let a = {
};
let b = {
    foo: 1
};
let c = {
    foo: 1, bar: 2
};
let d = {
    foo: 1,
    bar: 2
};
let e = {
    foo: function() {
        dosomething();
    }
};

let {
} = obj;
let {
    f
} = obj;
let {
    g, h
} = obj;
let {
    i,
    j
} = obj;
let {
    k = function() {
        dosomething();
    }
} = obj;
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

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", "never"]*/

let a = {};
let b = {foo: 1};
let c = {foo: 1, bar: 2};
let d = {foo: 1,
    bar: 2};
let e = {foo: function() {
    dosomething();
}};

let {} = obj;
let {f} = obj;
let {g, h} = obj;
let {i,
    j} = obj;
let {k = function() {
    dosomething();
}} = obj;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

multiline

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "multiline": true }]*/

let a = {
};
let b = {
    foo: 1
};
let c = {
    foo: 1, bar: 2
};
let d = {foo: 1,
    bar: 2};
let e = {foo: function() {
    dosomething();
}};

let {
} = obj;
let {
    f
} = obj;
let {
    g, h
} = obj;
let {i,
    j} = obj;
let {k = function() {
    dosomething();
}} = obj;
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

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "multiline": true }]*/

let a = {};
let b = {foo: 1};
let c = {foo: 1, bar: 2};
let d = {
    foo: 1,
    bar: 2
};
let e = {
    foo: function() {
        dosomething();
    }
};

let {} = obj;
let {f} = obj;
let {g, h} = obj;
let {
    i,
    j
} = obj;
let {
    k = function() {
        dosomething();
    }
} = obj;
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

minProperties

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "minProperties": 2 }]*/

let a = {
};
let b = {
    foo: 1
};
let c = {foo: 1, bar: 2};
let d = {foo: 1,
    bar: 2};
let e = {
    foo: function() {
        dosomething();
    }
};

let {
} = obj;
let {
    f
} = obj;
let {g, h} = obj;
let {i,
    j} = obj;
let {
    k = function() {
        dosomething();
    }
} = obj;
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

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "minProperties": 2 }]*/

let a = {};
let b = {foo: 1};
let c = {
    foo: 1, bar: 2
};
let d = {
    foo: 1,
    bar: 2
};
let e = {foo: function() {
    dosomething();
}};

let {} = obj;
let {f} = obj;
let {
    g, h
} = obj;
let {
    i,
    j
} = obj;
let {k = function() {
    dosomething();
}} = obj;
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

consistent

使用預設 { "consistent": true } 選項時，此規則的錯誤程式碼範例

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "consistent": true }]*/

let a = {foo: 1
};
let b = {
    foo: 1};
let c = {foo: 1, bar: 2
};
let d = {
    foo: 1, bar: 2};
let e = {foo: function() {
    dosomething();
    }
};
let f = {
    foo: function() {
    dosomething();}};

let {g
} = obj;
let {
    h} = obj;
let {i, j
} = obj;
let {k, l
} = obj;
let {
    m, n} = obj;
let {
    o, p} = obj;
let {q = function() {
    dosomething();
    }
} = obj;
let {
    r = function() {
        dosomething();
    }} = obj;
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

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "consistent": true }]*/

let empty1 = {};
let empty2 = {
};
let a = {foo: 1};
let b = {
    foo: 1
};
let c = {
    foo: 1, bar: 2
};
let d = {
    foo: 1,
    bar: 2
};
let e = {foo: function() {dosomething();}};
let f = {
    foo: function() {
        dosomething();
    }
};

let {} = obj;
let {
} = obj;
let {g} = obj;
let {
    h
} = obj;
let {i, j} = obj;
let {
    k, l
} = obj;
let {m,
    n} = obj;
let {
    o,
    p
} = obj;
let {q = function() {dosomething();}} = obj;
let {
    r = function() {
        dosomething();
    }
} = obj;
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

ObjectExpression 和 ObjectPattern

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "ObjectExpression": "always", "ObjectPattern": "never" }]*/

let a = {};
let b = {foo: 1};
let c = {foo: 1, bar: 2};
let d = {foo: 1,
    bar: 2};
let e = {foo: function() {
    dosomething();
}};

let {
} = obj;
let {
    f
} = obj;
let {
    g, h
} = obj;
let {
    i,
    j
} = obj;
let {
    k = function() {
        dosomething();
    }
} = obj;
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

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "ObjectExpression": "always", "ObjectPattern": "never" }]*/

let a = {
};
let b = {
    foo: 1
};
let c = {
    foo: 1, bar: 2
};
let d = {
    foo: 1,
    bar: 2
};
let e = {
    foo: function() {
        dosomething();
    }
};

let {} = obj;
let {f} = obj;
let {g, h} = obj;
let {i,
    j} = obj;
let {k = function() {
    dosomething();
}} = obj;
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

ImportDeclaration 和 ExportDeclaration

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "ImportDeclaration": "always", "ExportDeclaration": "never" }]*/

import {foo, bar} from 'foo-bar';
import {foo as f, baz} from 'foo-bar';
import {qux,
    foobar} from 'foo-bar';

export {
   foo,
   bar
};
export {
   foo as f,
   baz
} from 'foo-bar';
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

在 Playground 中開啟

/*eslint object-curly-newline: ["error", { "ImportDeclaration": "always", "ExportDeclaration": "never" }]*/

import {
    foo,
    bar
} from 'foo-bar';
import {
    baz, qux
} from 'foo-bar';
import {
    foo as f,
    foobar
} from 'foo-bar';

export { foo, bar } from 'foo-bar';
export { foo as f, baz } from 'foo-bar';
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

何時不該使用

如果您不想強制在開括號後和閉括號前保持一致的換行符，那麼停用此規則是安全的。

相容性

JSCS: requirePaddingNewLinesInObjects
JSCS: disallowPaddingNewLinesInObjects

版本

此規則在 ESLint v2.12.0 中引入。

資源

編輯此頁面

object-curly-newline

規則詳情

選項

always

never

multiline

minProperties

consistent

ObjectExpression 和 ObjectPattern

ImportDeclaration 和 ExportDeclaration

何時不該使用

相容性

相關規則

版本

資源