sort-keys

要求对对象键进行排序

在声明多个属性时，一些开发者更喜欢按字母顺序对属性名称进行排序，以便以后更容易找到和/或区分必要的属性。其他人则认为它增加了复杂性并成为维护的负担。

¥When declaring multiple properties, some developers prefer to sort property names alphabetically to more easily find and/or diff necessary properties at a later time. Others feel that it adds complexity and becomes burden to maintain.

规则详情

¥Rule Details

此规则检查对象表达式的所有属性定义并验证所有变量是否按字母顺序排序。

¥This rule checks all property definitions of object expressions and verifies that all variables are sorted alphabetically.

此规则的错误代码示例：

¥Examples of incorrect code for this rule:

在线运行

/*eslint sort-keys: "error"*/

let obj1 = {a: 1, c: 3, b: 2};
let obj2 = {a: 1, "c": 3, b: 2};

// Case-sensitive by default.
let obj3 = {a: 1, b: 2, C: 3};

// Non-natural order by default.
let obj4 = {1: a, 2: c, 10: b};

// This rule checks computed properties which have a simple name as well.
// Simple names are names which are expressed by an Identifier node or a Literal node.
const S = Symbol("s")
let obj5 = {a: 1, ["c"]: 3, b: 2};
let obj6 = {a: 1, [S]: 3, b: 2};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

此规则的正确代码示例：

¥Examples of correct code for this rule:

在线运行

/*eslint sort-keys: "error"*/

let obj1 = {a: 1, b: 2, c: 3};
let obj2 = {a: 1, "b": 2, c: 3};

// Case-sensitive by default.
let obj3 = {C: 3, a: 1, b: 2};

// Non-natural order by default.
let obj4 = {1: a, 10: b, 2: c};

// This rule checks computed properties which have a simple name as well.
let obj5 = {a: 1, ["b"]: 2, c: 3};
let obj6 = {a: 1, [b]: 2, c: 3};

// This rule ignores computed properties which have a non-simple name.
let obj7 = {a: 1, [c + d]: 3, b: 2};
let obj8 = {a: 1, ["c" + "d"]: 3, b: 2};
let obj9 = {a: 1, [`${c}`]: 3, b: 2};
let obj10 = {a: 1, [tag`c`]: 3, b: 2};

// This rule does not report unsorted properties that are separated by a spread property.
let obj11 = {b: 1, ...c, a: 2};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

选项

¥Options

{
    "sort-keys": ["error", "asc", {"caseSensitive": true, "natural": false, "minKeys": 2}]
}
1
2
3

第一个选项是 "asc" 或 "desc"。

¥The 1st option is "asc" or "desc".

"asc"（默认） - 强制属性按升序排列。

¥"asc" (default) - enforce properties to be in ascending order.
"desc" - 强制属性按降序排列。

¥"desc" - enforce properties to be in descending order.

第二个选项是具有以下属性的对象。

¥The 2nd option is an object which has the following properties.

caseSensitive - 如果是 true，则强制属性以区分大小写的顺序排列。默认为 true。

¥caseSensitive - if true, enforce properties to be in case-sensitive order. Default is true.
minKeys - 指定对象应具有的最少键数，以便对象的未排序键产生错误。默认为 2，这意味着默认情况下，所有具有未排序键的对象都会导致 lint 错误。

¥minKeys - Specifies the minimum number of keys that an object should have in order for the object’s unsorted keys to produce an error. Default is 2, which means by default all objects with unsorted keys will result in lint errors.
natural - 如果 true，则强制属性按自然顺序排列。默认为 false。Natural Order 以人类排序的方式比较包含字母和数字组合的字符串。它基本上按数字排序，而不是按字母排序。所以数字 10 在自然排序中排在数字 3 之后。

¥natural - if true, enforce properties to be in natural order. Default is false. Natural Order compares strings containing combination of letters and numbers in the way a human being would sort. It basically sorts numerically, instead of sorting alphabetically. So the number 10 comes after the number 3 in Natural Sorting.
allowLineSeparatedGroups - 如果是 true，则规则允许通过换行符对对象键进行分组。换句话说，属性后的空行将重置键的排序。默认为 false。

¥allowLineSeparatedGroups - if true, the rule allows to group object keys through line breaks. In other words, a blank line after a property will reset the sorting of keys. Default is false.
ignoreComputedKeys - 如果是 true，规则将忽略所有计算键并且不会报告由它们分隔的未排序属性。计算键将重置以下非计算键的排序。默认为 false。

¥ignoreComputedKeys - if true, the rule ignores all computed keys and doesn’t report unsorted properties separated by them. A computed key will reset the sorting of the following non-computed keys. Default is false.

列表示例：

¥Example for a list:

如果 natural 为真，则排序为 1 3 6 8 10

¥With natural as true, the ordering would be 1 3 6 8 10

如果 natural 为假，则排序为 1 10 3 6 8

¥With natural as false, the ordering would be 1 10 3 6 8

desc

"desc" 选项的错误代码示例：

¥Examples of incorrect code for the "desc" option:

在线运行

/*eslint sort-keys: ["error", "desc"]*/

let obj1 = {b: 2, c: 3, a: 1};
let obj2 = {"b": 2, c: 3, a: 1};

// Case-sensitive by default.
let obj3 = {C: 1, b: 3, a: 2};

// Non-natural order by default.
let obj4 = {10: b, 2: c, 1: a};
1
2
3
4
5
6
7
8
9
10

"desc" 选项的正确代码示例：

¥Examples of correct code for the "desc" option:

在线运行

/*eslint sort-keys: ["error", "desc"]*/

let obj1 = {c: 3, b: 2, a: 1};
let obj2 = {c: 3, "b": 2, a: 1};

// Case-sensitive by default.
let obj3 = {b: 3, a: 2, C: 1};

// Non-natural order by default.
let obj4 = {2: c, 10: b, 1: a};
1
2
3
4
5
6
7
8
9
10

caseSensitive

{caseSensitive: false} 选项的错误代码示例：

¥Examples of incorrect code for the {caseSensitive: false} option:

在线运行

/*eslint sort-keys: ["error", "asc", {caseSensitive: false}]*/

let obj1 = {a: 1, c: 3, C: 4, b: 2};
let obj2 = {a: 1, C: 3, c: 4, b: 2};
1
2
3
4

{caseSensitive: false} 选项的正确代码示例：

¥Examples of correct code for the {caseSensitive: false} option:

在线运行

/*eslint sort-keys: ["error", "asc", {caseSensitive: false}]*/

let obj1 = {a: 1, b: 2, c: 3, C: 4};
let obj2 = {a: 1, b: 2, C: 3, c: 4};
1
2
3
4

natural

{natural: true} 选项的错误代码示例：

¥Examples of incorrect code for the {natural: true} option:

在线运行

/*eslint sort-keys: ["error", "asc", {natural: true}]*/

let obj = {1: a, 10: c, 2: b};
1
2
3

{natural: true} 选项的正确代码示例：

¥Examples of correct code for the {natural: true} option:

在线运行

/*eslint sort-keys: ["error", "asc", {natural: true}]*/

let obj = {1: a, 2: b, 10: c};
1
2
3

minKeys

{minKeys: 4} 选项的错误代码示例：

¥Examples of incorrect code for the {minKeys: 4} option:

在线运行

/*eslint sort-keys: ["error", "asc", {minKeys: 4}]*/

// 4 keys
let obj1 = {
    b: 2,
    a: 1, // not sorted correctly (should be 1st key)
    c: 3,
    d: 4,
};

// 5 keys
let obj2 = {
    2: 'a',
    1: 'b', // not sorted correctly (should be 1st key)
    3: 'c',
    4: 'd',
    5: 'e',
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

{minKeys: 4} 选项的正确代码示例：

¥Examples of correct code for the {minKeys: 4} option:

在线运行

/*eslint sort-keys: ["error", "asc", {minKeys: 4}]*/

// 3 keys
let obj1 = {
    b: 2,
    a: 1,
    c: 3,
};

// 2 keys
let obj2 = {
    2: 'b',
    1: 'a',
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

allowLineSeparatedGroups

{allowLineSeparatedGroups: true} 选项的错误代码示例：

¥Examples of incorrect code for the {allowLineSeparatedGroups: true} option:

在线运行

/*eslint sort-keys: ["error", "asc", {allowLineSeparatedGroups: true}]*/

let obj1 = {
    b: 1,
    c () {

    },
    a: 3
}

let obj2 = {
    b: 1,
    c: 2,

    z () {

    },
    y: 3
}

let obj3 = {
    b: 1,
    c: 2,

    z () {

    },
    // comment
    y: 3,
}

let obj4 = {
    b: 1
    // comment before comma
    , a: 2
};
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

{allowLineSeparatedGroups: true} 选项的正确代码示例：

¥Examples of correct code for the {allowLineSeparatedGroups: true} option:

在线运行

/*eslint sort-keys: ["error", "asc", {allowLineSeparatedGroups: true}]*/

let obj1 = {
    e: 1,
    f: 2,
    g: 3,

    a: 4,
    b: 5,
    c: 6
}

let obj2 = {
    b: 1,

    // comment
    a: 4,
    c: 5,
}

let obj3 = {
    c: 1,
    d: 2,

    b () {

    },
    e: 3,
}

let obj4 = {
    c: 1,
    d: 2,
    // comment

    // comment
    b() {

    },
    e: 4
}

let obj5 = {
    b,

    [foo + bar]: 1,
    a
}

let obj6 = {
    b: 1
    // comment before comma

    ,
    a: 2
};

var obj7 = {
    b: 1,

    a: 2,
    ...z,
    c: 3
}
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
57
58
59
60
61
62
63
64

ignoreComputedKeys

{ignoreComputedKeys: true} 选项的正确代码示例：

¥Examples of correct code for the {ignoreComputedKeys: true} option:

在线运行

/*eslint sort-keys: ["error", "asc", {ignoreComputedKeys: true}]*/

let obj1 = {
    [b]: 1,
    a: 2
}

let obj2 = {
    c: 1,
    [b]: 2,
    a: 3
}

let obj3 = {
    c: 1,
    ["b"]: 2,
    a: 3
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

何时不使用

¥When Not To Use It

如果你不想通知属性的顺序，那么禁用此规则是安全的。

¥If you don’t want to notify about properties’ order, then it’s safe to disable this rule.

兼容性

¥Compatibility

JSCS:validateOrderInObjectKeys

版本

此规则是在 ESLint v3.3.0 中引入。

sort-keys

规则详情

选项

desc

caseSensitive

natural

minKeys

allowLineSeparatedGroups

ignoreComputedKeys

何时不使用

兼容性

相关规则

版本

资源