@stylistic/

comma-dangle

根据 ECMAScript 5（以及 ECMAScript 3！）规范，对象字面量中的尾随逗号是有效的。但是，IE8（不在 IE8 文档模式下）及以下版本在遇到 JavaScript 中的尾随逗号时会抛出错误。

var foo = {
    bar: "baz",
    qux: "quux",
};

尾随逗号简化了向对象和数组添加和删除项的操作，因为只需要修改您正在修改的行。支持尾随逗号的另一个论据是，它提高了在向对象或数组添加或删除项时差异的清晰度

不太清楚

 var foo = {
-    bar: "baz",
-    qux: "quux"
+    bar: "baz"
 };

更清楚

 var foo = {
     bar: "baz",
-    qux: "quux",
 };

规则详细信息

此规则强制在对象和数组字面量中一致使用尾随逗号。

选项

此规则具有字符串选项或对象选项

{
    "comma-dangle": ["error", "never"],
    // or
    "comma-dangle": ["error", {
        "arrays": "never",
        "objects": "never",
        "imports": "never",
        "exports": "never",
        "functions": "never"
    }]
}

• "never"（默认）禁止尾随逗号
• "always" 要求尾随逗号
• "always-multiline" 要求在最后一个元素或属性位于与结束 ] 或 } 不同的行时使用尾随逗号，并在最后一个元素或属性位于与结束 ] 或 } 相同的行时禁止使用尾随逗号。
• "only-multiline" 允许（但不强制要求）在最后一个元素或属性位于与结束 ] 或 } 不同的行时使用尾随逗号，并在最后一个元素或属性位于与结束 ] 或 } 相同的行时禁止使用尾随逗号。

您还可以使用对象选项为每种语法类型配置此规则。以下每个选项都可以设置为 "never"、"always"、"always-multiline"、"only-multiline" 或 "ignore"。除非另有说明，否则每个选项的默认值为 "never"。

• arrays 用于数组字面量和解构的数组模式。（例如 let [a,] = [1,];）
• objects 用于对象字面量和解构的对象模式。（例如 let {a,} = {a: 1};）
• imports 用于 ES 模块的导入声明。（例如 import {a,} from "foo";）
• exports 用于 ES 模块的导出声明。（例如 export {a,};）
• functions 用于函数声明和函数调用。（例如 (function(a,){ })(b,);）
  • functions 仅应在对 ECMAScript 2017 或更高版本进行代码风格检查时启用。

never

使用默认 "never" 选项时，此规则的错误代码示例

/*eslint @stylistic/comma-dangle: ["error", "never"]*/

var foo = {
    bar: "baz",
    qux: "quux"
,
};

var arr = [1,2
,
];

foo({
  bar: "baz",
  qux: "quux"
,
});

incorrect

使用默认 "never" 选项时，此规则的正确代码示例

/*eslint @stylistic/comma-dangle: ["error", "never"]*/

var foo = {
    bar: "baz",
    qux: "quux"
};

var arr = [1,2];

foo({
  bar: "baz",
  qux: "quux"
});

correct

always

使用 "always" 选项时，此规则的错误代码示例

/*eslint @stylistic/comma-dangle: ["error", "always"]*/

var foo = {
    bar: "baz",
    qux: "quux"

};

var arr = [1,2
]
;

foo({
  bar: "baz",
  qux: "quux"

}
)
;

incorrect

使用 "always" 选项时，此规则的正确代码示例

/*eslint @stylistic/comma-dangle: ["error", "always"]*/

var foo = {
    bar: "baz",
    qux: "quux",
};

var arr = [1,2,];

foo({
  bar: "baz",
  qux: "quux",
}
)
;

correct

always-multiline

使用 "always-multiline" 选项时，此规则的错误代码示例

/*eslint @stylistic/comma-dangle: ["error", "always-multiline"]*/

var foo = {
    bar: "baz",
    qux: "quux"

};

var foo = { bar: "baz", qux: "quux"
,
 };

var arr = [1,2
,
];

var arr = [1,
    2
,
];

var arr = [
    1,
    2

];

foo({
  bar: "baz",
  qux: "quux"

});

incorrect

使用 "always-multiline" 选项时，此规则的正确代码示例

/*eslint @stylistic/comma-dangle: ["error", "always-multiline"]*/

var foo = {
    bar: "baz",
    qux: "quux",
};

var foo = {bar: "baz", qux: "quux"};
var arr = [1,2];

var arr = [1,
    2];

var arr = [
    1,
    2,
];

foo({
  bar: "baz",
  qux: "quux",
});

correct

only-multiline

使用 "only-multiline" 选项时，此规则的错误代码示例

/*eslint @stylistic/comma-dangle: ["error", "only-multiline"]*/

var foo = { bar: "baz", qux: "quux"
,
 };

var arr = [1,2
,
];

var arr = [1,
    2
,
];

incorrect

使用 "only-multiline" 选项时，此规则的正确代码示例

/*eslint @stylistic/comma-dangle: ["error", "only-multiline"]*/

var foo = {
    bar: "baz",
    qux: "quux",
};

var foo = {
    bar: "baz",
    qux: "quux"
};

var foo = {bar: "baz", qux: "quux"};
var arr = [1,2];

var arr = [1,
    2];

var arr = [
    1,
    2,
];

var arr = [
    1,
    2
];

foo({
  bar: "baz",
  qux: "quux",
});

foo({
  bar: "baz",
  qux: "quux"
});

correct

functions

此规则使用 {"functions": "never"} 选项时，错误代码示例

/*eslint @stylistic/comma-dangle: ["error", {"functions": "never"}]*/

function foo(a, b
,
) {
}

foo(a, b
,
);
new foo(a, b
,
);

incorrect

此规则使用 {"functions": "never"} 选项时，正确代码示例

/*eslint @stylistic/comma-dangle: ["error", {"functions": "never"}]*/

function foo(a, b) {
}

foo(a, b);
new foo(a, b);

correct

此规则使用 {"functions": "always"} 选项时，错误代码示例

/*eslint @stylistic/comma-dangle: ["error", {"functions": "always"}]*/

function foo(a, b
)
 {
}

foo(a, b
)
;
new foo(a, b
)
;

incorrect

此规则使用 {"functions": "always"} 选项时，正确代码示例

/*eslint @stylistic/comma-dangle: ["error", {"functions": "always"}]*/

function foo(a, b,) {
}

foo(a, b,);
new foo(a, b,);

correct

何时不使用它

如果您不关心悬挂逗号，可以关闭此规则。

TypeScript 特定

ts/comma-dangle

选项

除了 js/comma-dangle 规则支持的选项外，该规则还添加了以下选项

• "enums" 用于枚举中的尾随逗号。（例如 enum Foo = {Bar,}）
• "generics" 用于泛型中的尾随逗号。（例如 function foo<T,>() {}）
• "tuples" 用于元组中的尾随逗号。（例如 type Foo = [string,]）