{ "accessor-pairs": { "name": "accessor-pairs", "value": ["error", { "setWithoutGet": true, "getWithoutSet": false }], "description": "setter 必须有对应的 getter，getter 可以没有对应的 setter", "reason": "", "badExample": "const foo = {\n eslint(accessor-pairs)\">set bar(value) {\n this.barValue = 'bar ' + value;\n },\n};", "goodExample": "const foo = {\n set bar(value) {\n this.barValue = 'bar ' + value;\n },\n get bar() {\n return this.barValue;\n },\n};\nconst bar = {\n get foo() {\n return this.fooValue;\n },\n};", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "array-callback-return": { "name": "array-callback-return", "value": "error", "description": "数组的方法除了 forEach 之外，回调函数必须有返回值", "reason": "", "badExample": "const foo = [1, 2, 3].map((num) eslint(array-callback-return)\">=> {\n console.log(num * num);\n});", "goodExample": "const foo = [1, 2, 3].map((num) => {\n return num * num;\n});", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "block-scoped-var": { "name": "block-scoped-var", "value": "off", "description": "将 var 定义的变量视为块作用域，禁止在块外使用", "reason": "已经禁止使用 var 了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "camelcase": { "name": "camelcase", "value": "off", "description": "变量名必须是 camelcase 风格的", "reason": "很多 api 或文件名都不是 camelcase 风格的", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "capitalized-comments": { "name": "capitalized-comments", "value": "off", "description": "注释的首字母必须大写", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "class-methods-use-this": { "name": "class-methods-use-this", "value": "off", "description": "在类的非静态方法中，必须存在对 this 的引用", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "complexity": { "name": "complexity", "value": ["error", { "max": 20 }], "description": "禁止函数的循环复杂度超过 20", "reason": "https://en.wikipedia.org/wiki/Cyclomatic_complexity", "badExample": "eslint(complexity)\">function foo() {\n if (i === 1) console.log(i);\n if (i === 2) console.log(i);\n if (i === 3) console.log(i);\n if (i === 4) console.log(i);\n if (i === 5) console.log(i);\n if (i === 6) console.log(i);\n if (i === 7) console.log(i);\n if (i === 8) console.log(i);\n if (i === 9) console.log(i);\n if (i === 10) console.log(i);\n if (i === 11) console.log(i);\n if (i === 12) console.log(i);\n if (i === 13) console.log(i);\n if (i === 14) console.log(i);\n if (i === 15) console.log(i);\n if (i === 16) console.log(i);\n if (i === 17) console.log(i);\n if (i === 18) console.log(i);\n if (i === 19) console.log(i);\n if (i === 20) console.log(i);\n}", "goodExample": "function foo() {\n if (i === 1) console.log(i);\n if (i === 2) console.log(i);\n if (i === 3) console.log(i);\n if (i === 4) console.log(i);\n if (i === 5) console.log(i);\n if (i === 6) console.log(i);\n if (i === 7) console.log(i);\n if (i === 8) console.log(i);\n if (i === 9) console.log(i);\n if (i === 10) console.log(i);\n bar(i);\n}\nfunction bar(i) {\n if (i === 11) console.log(i);\n if (i === 12) console.log(i);\n if (i === 13) console.log(i);\n if (i === 14) console.log(i);\n if (i === 15) console.log(i);\n if (i === 16) console.log(i);\n if (i === 17) console.log(i);\n if (i === 18) console.log(i);\n if (i === 19) console.log(i);\n if (i === 20) console.log(i);\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "consistent-return": { "name": "consistent-return", "value": "off", "description": "禁止函数在不同分支返回不同类型的值", "reason": "缺少 TypeScript 的支持，类型判断是不准确的", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "consistent-this": { "name": "consistent-this", "value": "off", "description": "限制 this 的别名", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "constructor-super": { "name": "constructor-super", "value": "error", "description": "constructor 中必须有 super", "reason": "", "badExample": "class Foo extends Bar {\n eslint(constructor-super)\">constructor() {}\n}", "goodExample": "class Foo extends Bar {\n constructor() {\n super();\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "default-case": { "name": "default-case", "value": "off", "description": "switch 语句必须有 default", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "default-case-last": { "name": "default-case-last", "value": "error", "description": "switch 语句中的 default 必须在最后", "reason": "", "badExample": "switch (foo) {\n eslint(default-case-last)\">default:\n bar();\n break;\n case 1:\n baz();\n break;\n}", "goodExample": "switch (foo) {\n case 1:\n baz();\n break;\n default:\n bar();\n break;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "default-param-last": { "name": "default-param-last", "value": "off", "description": "有默认值的参数必须放在函数参数的末尾", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "dot-notation": { "name": "dot-notation", "value": "off", "description": "禁止使用 foo['bar']，必须写成 foo.bar", "reason": "当需要写一系列属性的时候，可以更统一", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "eqeqeq": { "name": "eqeqeq", "value": "off", "description": "必须使用 === 或 !==，禁止使用 == 或 !=", "reason": "", "badExample": "if (foo eslint(eqeqeq)\">== 1) {\n}\nif (bar eslint(eqeqeq)\">!= null) {\n}", "goodExample": "if (foo === 1) {\n}\nif (bar !== null) {\n}", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "for-direction": { "name": "for-direction", "value": "error", "description": "禁止方向错误的 for 循环", "reason": "", "badExample": "eslint(for-direction)\">for (let i = 0; i < 10; i--) {\n // do something\n}", "goodExample": "for (let i = 0; i < 10; i++) {\n // do something\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "func-name-matching": { "name": "func-name-matching", "value": ["error", "always", { "includeCommonJSModuleExports": false }], "description": "函数赋值给变量的时候，函数名必须与变量名一致", "reason": "", "badExample": "const eslint(func-name-matching)\">foo = function bar() {};", "goodExample": "const foo = function () {};\nconst bar = function bar() {};", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "func-names": { "name": "func-names", "value": "off", "description": "函数必须有名字", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "func-style": { "name": "func-style", "value": "off", "description": "必须只使用函数声明或只使用函数表达式", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "getter-return": { "name": "getter-return", "value": "error", "description": "getter 必须有返回值，并且禁止返回空", "reason": "", "badExample": "const user = {\n eslint(getter-return)\">get name() {\n // do something\n },\n};\nclass User {\n get name() {\n eslint(getter-return)\">return;\n }\n}", "goodExample": "const user = {\n get name() {\n return 'Alex';\n },\n};\nclass User {\n get name() {\n return this.name;\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "grouped-accessor-pairs": { "name": "grouped-accessor-pairs", "value": "error", "description": "setter 和 getter 必须写在一起", "reason": "", "badExample": "const foo = {\n set bar(value) {\n this.barValue = 'bar ' + value;\n },\n baz: 1,\n eslint(grouped-accessor-pairs)\">get bar() {\n return this.barValue;\n },\n};", "goodExample": "const foo = {\n set bar(value) {\n this.barValue = 'bar ' + value;\n },\n get bar() {\n return this.barValue;\n },\n baz: 1,\n};", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "guard-for-in": { "name": "guard-for-in", "value": "error", "description": "for in 内部必须有 hasOwnProperty", "reason": "", "badExample": "eslint(guard-for-in)\">for (key in foo) {\n doSomething(key);\n}", "goodExample": "for (key in foo) {\n if (Object.prototype.hasOwnProperty.call(foo, key)) {\n doSomething(key);\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "id-denylist": { "name": "id-denylist", "value": "off", "description": "禁止使用指定的标识符", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "id-length": { "name": "id-length", "value": "off", "description": "限制变量名长度", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "id-match": { "name": "id-match", "value": "off", "description": "限制变量名必须匹配指定的正则表达式", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "init-declarations": { "name": "init-declarations", "value": "off", "description": "变量必须在定义的时候赋值", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "line-comment-position": { "name": "line-comment-position", "value": "off", "description": "单行注释必须写在上一行", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "lines-between-class-members": { "name": "lines-between-class-members", "value": "off", "description": "类的成员之间是否需要空行", "reason": "有时为了紧凑需要挨在一起，有时为了可读性需要空一行", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "max-classes-per-file": { "name": "max-classes-per-file", "value": "off", "description": "限制一个文件中类的数量", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "max-depth": { "name": "max-depth", "value": ["error", 5], "description": "代码块嵌套的深度禁止超过 5 层", "reason": "", "badExample": "function foo() {\n if (true) {\n if (true) {\n if (true) {\n if (true) {\n if (true) {\n eslint(max-depth)\">if (true) {\n }\n }\n }\n }\n }\n }\n}", "goodExample": "function foo() {\n if (true) {\n if (true) {\n if (true) {\n if (true) {\n if (true) {\n }\n }\n }\n }\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "max-lines": { "name": "max-lines", "value": "off", "description": "限制一个文件最多的行数", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "max-lines-per-function": { "name": "max-lines-per-function", "value": "off", "description": "限制函数块中的代码行数", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "max-nested-callbacks": { "name": "max-nested-callbacks", "value": ["error", 3], "description": "回调函数嵌套禁止超过 3 层，多了请用 async await 替代", "reason": "", "badExample": "foo(() => {\n bar(() => {\n baz(() => {\n qux(eslint(max-nested-callbacks)\">() => {});\n });\n });\n});", "goodExample": "foo(async () => {\n await bar();\n await baz();\n await qux();\n});", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "max-params": { "name": "max-params", "value": ["off", 3], "description": "函数的参数禁止超过 3 个", "reason": "", "badExample": "eslint(max-params)\">function foo(a1, a2, a3, a4) {}", "goodExample": "function foo(a1, a2, a3) {}\nfunction bar({ a1, a2, a3, a4 }) {}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "max-statements": { "name": "max-statements", "value": "off", "description": "限制函数块中的语句数量", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "max-statements-per-line": { "name": "max-statements-per-line", "value": "off", "description": "限制一行中的语句数量", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "multiline-comment-style": { "name": "multiline-comment-style", "value": "off", "description": "约束多行注释的格式", "reason": "能写注释已经不容易了，不需要限制太多", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "new-cap": { "name": "new-cap", "value": ["error", { "newIsCap": true, "capIsNew": false, "properties": true }], "description": "new 后面的类名必须首字母大写", "reason": "", "badExample": "new eslint(new-cap)\">foo();\nnew foo.eslint(new-cap)\">bar();", "goodExample": "new Foo();\nnew foo.Bar();\nFoo();", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-alert": { "name": "no-alert", "value": "off", "description": "禁止使用 alert", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-array-constructor": { "name": "no-array-constructor", "value": "error", "description": "禁止使用 Array 构造函数时传入的参数超过一个", "reason": "参数为一个时表示创建一个指定长度的数组，比较常用\n参数为多个时表示创建一个指定内容的数组，此时可以用数组字面量实现，不必使用构造函数", "badExample": "const foo = eslint(no-array-constructor)\">Array(0, 1, 2); // [0, 1, 2]\nconst bar = eslint(no-array-constructor)\">new Array(0, 1, 2); // [0, 1, 2]", "goodExample": "const foo = [0, 1, 2];\nArray(3); // [empty × 3]\nnew Array(3); // [empty × 3]\nArray(3).fill('foo'); // [\"foo\", \"foo\", \"foo\"]\nnew Array(3).fill('foo'); // [\"foo\", \"foo\", \"foo\"]", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-async-promise-executor": { "name": "no-async-promise-executor", "value": "error", "description": "禁止将 async 函数做为 new Promise 的回调函数", "reason": "出现这种情况时，一般不需要使用 new Promise 实现异步了", "badExample": "new Promise(eslint(no-async-promise-executor)\">async (resolve) => {\n setTimeout(resolve, 1000);\n});", "goodExample": "new Promise((resolve) => {\n setTimeout(resolve, 1000);\n});", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-await-in-loop": { "name": "no-await-in-loop", "value": "off", "description": "禁止将 await 写在循环里，因为这样就无法同时发送多个异步请求了", "reason": "要求太严格了，有时需要在循环中写 await", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-bitwise": { "name": "no-bitwise", "value": "off", "description": "禁止使用位运算", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-caller": { "name": "no-caller", "value": "error", "description": "禁止使用 caller 或 callee", "reason": "它们是已废弃的语法", "badExample": "function foo(n) {\n if (n <= 0) {\n return;\n }\n eslint(no-caller)\">arguments.callee(n - 1);\n}", "goodExample": "function foo(n) {\n if (n <= 0) {\n return;\n }\n foo(n - 1);\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-case-declarations": { "name": "no-case-declarations", "value": "error", "description": "switch 的 case 内有变量定义的时候，必须使用大括号将 case 内变成一个代码块", "reason": "", "badExample": "switch (foo) {\n case 1:\n eslint(no-case-declarations)\">const x = 1;\n break;\n}", "goodExample": "switch (foo) {\n case 1: {\n const x = 1;\n break;\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-class-assign": { "name": "no-class-assign", "value": "error", "description": "禁止对已定义的 class 重新赋值", "reason": "", "badExample": "class Foo {}\neslint(no-class-assign)\">Foo = {};", "goodExample": "class Foo {}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-compare-neg-zero": { "name": "no-compare-neg-zero", "value": "error", "description": "禁止与负零进行比较", "reason": "", "badExample": "if (eslint(no-compare-neg-zero)\">foo === -0) {\n}", "goodExample": "if (foo === 0) {\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-cond-assign": { "name": "no-cond-assign", "value": ["error", "except-parens"], "description": "禁止在测试表达式中使用赋值语句，除非这个赋值语句被括号包起来了", "reason": "", "badExample": "if (eslint(no-cond-assign)\">foo = 0) {\n}", "goodExample": "if (foo === 0) {\n}\nif (bar === (foo = 0)) {\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-console": { "name": "no-console", "value": "off", "description": "禁止使用 console", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-const-assign": { "name": "no-const-assign", "value": "error", "description": "禁止对使用 const 定义的常量重新赋值", "reason": "", "badExample": "const foo = 1;\neslint(no-const-assign)\">foo = 2;", "goodExample": "let foo = 1;\nfoo = 2;\n\nfor (const bar in [1, 2, 3]) {\n console.log(bar);\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-constant-condition": { "name": "no-constant-condition", "value": ["error", { "checkLoops": false }], "description": "禁止将常量作为分支条件判断中的测试表达式，但允许作为循环条件判断中的测试表达式", "reason": "", "badExample": "if (eslint(no-constant-condition)\">true) {\n}\nconst foo = eslint(no-constant-condition)\">0 ? 'bar' : 'baz';", "goodExample": "for (; true; ) {\n if (foo === 0) break;\n}\nwhile (true) {\n if (foo === 0) break;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-constructor-return": { "name": "no-constructor-return", "value": "error", "description": "禁止在构造函数中返回值", "reason": "", "badExample": "class Foo {\n constructor(bar) {\n this.bar = bar;\n eslint(no-constructor-return)\">return bar;\n }\n}", "goodExample": "class Foo {\n constructor(bar) {\n if (!bar) {\n return;\n }\n this.bar = bar;\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-continue": { "name": "no-continue", "value": "off", "description": "禁止使用 continue", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-control-regex": { "name": "no-control-regex", "value": "off", "description": "禁止在正则表达式中出现 Ctrl 键的 ASCII 表示，即禁止使用 /\\x1f/", "reason": "几乎不会遇到这种场景", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-debugger": { "name": "no-debugger", "value": "error", "description": "禁止使用 debugger", "reason": "", "badExample": "if (foo) {\n eslint(no-debugger)\">debugger;\n}", "goodExample": "if (foo) {\n // debugger;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-delete-var": { "name": "no-delete-var", "value": "off", "description": "禁止对一个变量使用 delete", "reason": "编译阶段就会报错了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-div-regex": { "name": "no-div-regex", "value": "off", "description": "禁止在正则表达式中出现形似除法操作符的开头，如 let a = /=foo/", "reason": "有代码高亮的话，在阅读这种代码时，也完全不会产生歧义或理解上的困难", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-dupe-args": { "name": "no-dupe-args", "value": "off", "description": "禁止在函数参数中出现重复名称的参数", "reason": "编译阶段就会报错了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-dupe-class-members": { "name": "no-dupe-class-members", "value": "error", "description": "禁止重复定义类的成员", "reason": "", "badExample": "class Foo {\n bar() {}\n eslint(no-dupe-class-members)\">bar() {}\n}", "goodExample": "class Foo {\n bar() {}\n baz() {}\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-dupe-else-if": { "name": "no-dupe-else-if", "value": "error", "description": "禁止 if else 的条件判断中出现重复的条件", "reason": "", "badExample": "if (foo) {\n console.log(foo);\n} else if (eslint(no-dupe-else-if)\">foo) {\n console.log(bar);\n}", "goodExample": "if (foo) {\n console.log(foo);\n} else if (bar) {\n console.log(bar);\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-dupe-keys": { "name": "no-dupe-keys", "value": "error", "description": "禁止在对象字面量中出现重复的键名", "reason": "", "badExample": "const foo = {\n bar: 1,\n eslint(no-dupe-keys)\">bar: 2,\n};", "goodExample": "const foo = {\n bar: 1,\n baz: 2,\n};", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-duplicate-case": { "name": "no-duplicate-case", "value": "error", "description": "禁止在 switch 语句中出现重复测试表达式的 case", "reason": "", "badExample": "switch (foo) {\n case 1:\n break;\n case 2:\n break;\n eslint(no-duplicate-case)\">case 1:\n break;\n}", "goodExample": "switch (foo) {\n case 1:\n break;\n case 2:\n break;\n case 3:\n break;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-duplicate-imports": { "name": "no-duplicate-imports", "value": "error", "description": "禁止重复导入模块", "reason": "", "badExample": "import { readFile } from 'fs';\neslint(no-duplicate-imports)\">import { writeFile } from 'fs';", "goodExample": "import { readFile, writeFile } from 'fs';", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-else-return": { "name": "no-else-return", "value": "off", "description": "禁止在 else 内使用 return，必须改为提前结束", "reason": "else 中使用 return 可以使代码结构更清晰", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-empty": { "name": "no-empty", "value": ["error", { "allowEmptyCatch": true }], "description": "禁止出现空代码块，允许 catch 为空代码块", "reason": "", "badExample": "if (foo) eslint(no-empty)\">{\n}", "goodExample": "if (foo) {\n // do something\n}\ntry {\n // do something\n} catch (e) {}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-empty-character-class": { "name": "no-empty-character-class", "value": "error", "description": "禁止在正则表达式中使用空的字符集 []", "reason": "", "badExample": "const reg = eslint(no-empty-character-class)\">/abc[]/;", "goodExample": "const reg = /abc[a-z]/;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-empty-function": { "name": "no-empty-function", "value": "off", "description": "不允许有空函数", "reason": "有时需要将一个空函数设置为某个项的默认值", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-empty-pattern": { "name": "no-empty-pattern", "value": "error", "description": "禁止解构赋值中出现空 {} 或 []", "reason": "", "badExample": "const eslint(no-empty-pattern)\">{} = foo;", "goodExample": "const { bar } = foo;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-eq-null": { "name": "no-eq-null", "value": "error", "description": "禁止使用 foo == null，必须使用 foo === null", "reason": "", "badExample": "if (eslint(no-eq-null)\">foo == null) {\n}", "goodExample": "if (foo === null) {\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-eval": { "name": "no-eval", "value": "error", "description": "禁止使用 eval", "reason": "", "badExample": "eslint(no-eval)\">eval('const foo = 0');", "goodExample": "const foo = 0;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-ex-assign": { "name": "no-ex-assign", "value": "error", "description": "禁止将 catch 的第一个参数 error 重新赋值", "reason": "", "badExample": "try {\n} catch (e) {\n eslint(no-ex-assign)\">e = 10;\n}", "goodExample": "try {\n} catch (e) {\n console.error(e);\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-extend-native": { "name": "no-extend-native", "value": "off", "description": "禁止修改原生对象", "reason": "修改原生对象可能会与将来版本的 js 冲突", "badExample": "eslint(no-extend-native)\">Array.prototype.flat = function () {\n // do something\n};\n\n[1, [2, 3]].flat();", "goodExample": "function flat(arr) {\n // do something\n}\n\nflat([1, [2, 3]]);", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-extra-bind": { "name": "no-extra-bind", "value": "error", "description": "禁止出现没必要的 bind", "reason": "", "badExample": "(function () {\n foo();\n}.eslint(no-extra-bind)\">bind(bar));", "goodExample": "(function () {\n this.foo();\n}.bind(bar));", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-extra-boolean-cast": { "name": "no-extra-boolean-cast", "value": "error", "description": "禁止不必要的布尔类型转换", "reason": "", "badExample": "if (eslint(no-extra-boolean-cast)\">!!foo) {\n}\nif (eslint(no-extra-boolean-cast)\">Boolean(foo)) {\n}", "goodExample": "if (foo) {\n}\nif (!foo) {\n}", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-extra-label": { "name": "no-extra-label", "value": "off", "description": "禁止出现没必要的 label", "reason": "已经禁止使用 label 了", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-fallthrough": { "name": "no-fallthrough", "value": "error", "description": "switch 的 case 内必须有 break, return 或 throw，空的 case 除外", "reason": "", "badExample": "switch (foo) {\n case 1:\n doSomething();\n eslint(no-fallthrough)\">case 2:\n doSomethingElse();\n}", "goodExample": "switch (foo) {\n case 1:\n doSomething();\n break;\n case 2:\n doSomethingElse();\n}\nswitch (foo) {\n case 1:\n case 2:\n doSomething();\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-func-assign": { "name": "no-func-assign", "value": "error", "description": "禁止将一个函数声明重新赋值", "reason": "", "badExample": "function foo() {}\neslint(no-func-assign)\">foo = 1;", "goodExample": "let foo = function () {};\nfoo = 1;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-global-assign": { "name": "no-global-assign", "value": "error", "description": "禁止对全局变量赋值", "reason": "", "badExample": "eslint(no-global-assign)\">Object = null;", "goodExample": "foo = null;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-implicit-coercion": { "name": "no-implicit-coercion", "value": ["error", { "allow": ["!!"] }], "description": "禁止使用 ~+ 等难以理解的类型转换，仅允许使用 !!", "reason": "", "badExample": "const b = eslint(no-implicit-coercion)\">~foo.indexOf('.');\nconst n = eslint(no-implicit-coercion)\">+foo;\nconst m = eslint(no-implicit-coercion)\">1 * foo;\nconst s = eslint(no-implicit-coercion)\">'' + foo;\neslint(no-implicit-coercion)\">foo += '';", "goodExample": "const b = foo.indexOf('.') !== -1;\nconst n = Number(foo);\nconst m = Number(foo);\nconst s = String(foo);\nfoo = String(foo);\n\nconst c = !!foo;", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-implicit-globals": { "name": "no-implicit-globals", "value": "off", "description": "禁止在全局作用域下定义变量或申明函数", "reason": "模块化之后，不会出现这种在全局作用域下定义变量的情况", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-implied-eval": { "name": "no-implied-eval", "value": "error", "description": "禁止在 setTimeout 或 setInterval 中传入字符串", "reason": "", "badExample": "eslint(no-implied-eval)\">setTimeout('alert(\"Hello World\");', 1000);", "goodExample": "setTimeout(() => {\n alert('Hello World');\n}, 1000);", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-import-assign": { "name": "no-import-assign", "value": "error", "description": "禁止对导入的模块进行赋值", "reason": "", "badExample": "import foo from 'foo';\neslint(no-import-assign)\">foo = 1;\n\nimport * as bar from 'bar';\neslint(no-import-assign)\">bar.baz = 1;", "goodExample": "import foo from 'foo';\nfoo.baz = 1;\n\nimport * as bar from 'bar';\nbar.baz.qux = 1;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-inline-comments": { "name": "no-inline-comments", "value": "off", "description": "禁止在代码后添加单行注释", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-inner-declarations": { "name": "no-inner-declarations", "value": ["error", "both"], "description": "禁止在 if 代码块内出现函数声明", "reason": "", "badExample": "if (foo) {\n eslint(no-inner-declarations)\">function bar() {}\n}", "goodExample": "if (foo) {\n const bar = function () {};\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-invalid-regexp": { "name": "no-invalid-regexp", "value": "error", "description": "禁止在 RegExp 构造函数中出现非法的正则表达式", "reason": "", "badExample": "const reg1 = eslint(no-invalid-regexp)\">new RegExp('[');\nconst reg2 = eslint(no-invalid-regexp)\">new RegExp('.', 'z');", "goodExample": "const reg1 = new RegExp('[a-z]');\nconst reg2 = new RegExp('.', 'g');", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-invalid-this": { "name": "no-invalid-this", "value": "off", "description": "禁止在类之外的地方使用 this", "reason": "只允许在 class 中使用 this", "badExample": "function foo() {\n eslint(no-invalid-this)\">this.a = 0;\n}", "goodExample": "class Foo {\n constructor() {\n this.a = 0;\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-irregular-whitespace": { "name": "no-irregular-whitespace", "value": ["error", { "skipStrings": true, "skipComments": false, "skipRegExps": true, "skipTemplates": true }], "description": "禁止使用特殊空白符（比如全角空格），除非是出现在字符串、正则表达式或模版字符串中", "reason": "", "badExample": "function foo()eslint(no-irregular-whitespace)\">　{\n}", "goodExample": "const foo = '　';\nconst bar = /　/;\nconst baz = `　`;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-iterator": { "name": "no-iterator", "value": "error", "description": "禁止使用 __iterator__", "reason": "__iterator__ 是一个已废弃的属性\n使用 [Symbol.iterator] 替代它", "badExample": "eslint(no-iterator)\">Foo.prototype.__iterator__ = function () {\n return new FooIterator(this);\n};", "goodExample": "let foo = {};\nfoo[Symbol.iterator] = function* () {\n yield 1;\n yield 2;\n yield 3;\n};\nconsole.log([...foo]);\n// [1, 2, 3]", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-label-var": { "name": "no-label-var", "value": "off", "description": "禁止 label 名称与已定义的变量重复", "reason": "已经禁止使用 label 了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-labels": { "name": "no-labels", "value": "error", "description": "禁止使用 label", "reason": "", "badExample": "eslint(no-labels)\">loop:\n for (let i = 0; i < 5; i++) {\n if (i === 1) {\n eslint(no-labels)\">continue loop;\n }\n console.log(i);\n }\n// 0 2 3 4", "goodExample": "for (let i = 0; i < 5; i++) {\n if (i === 1) {\n continue;\n }\n console.log(i);\n}\n// 0 2 3 4", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-lone-blocks": { "name": "no-lone-blocks", "value": "error", "description": "禁止使用没必要的 {} 作为代码块", "reason": "", "badExample": "eslint(no-lone-blocks)\">{\n foo();\n}", "goodExample": "if (foo) {\n bar();\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-lonely-if": { "name": "no-lonely-if", "value": "off", "description": "禁止 else 中只有一个单独的 if", "reason": "单独的 if 可以把逻辑表达的更清楚", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-loop-func": { "name": "no-loop-func", "value": "off", "description": "禁止在循环内的函数内部出现循环体条件语句中定义的变量", "reason": "使用 let 就已经解决了这个问题了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-loss-of-precision": { "name": "no-loss-of-precision", "value": "error", "description": "禁止使用超出 js 精度范围的数字", "reason": "", "badExample": "const foo = eslint(no-loss-of-precision)\">5123000000000000000000000000001;", "goodExample": "const foo = 12345;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-magic-numbers": { "name": "no-magic-numbers", "value": "off", "description": "禁止使用 magic numbers", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-misleading-character-class": { "name": "no-misleading-character-class", "value": "error", "description": "禁止正则表达式中使用肉眼无法区分的特殊字符", "reason": "某些特殊字符很难看出差异，最好不要在正则中使用", "badExample": "eslint(no-misleading-character-class)\">/^[Á]$/u.test('Á'); // false", "goodExample": "/^[A]$/u.test('A'); // true", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-multi-assign": { "name": "no-multi-assign", "value": "off", "description": "禁止连续赋值，比如 foo = bar = 1", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-multi-str": { "name": "no-multi-str", "value": "error", "description": "禁止使用 \\ 来换行字符串", "reason": "", "badExample": "const foo = eslint(no-multi-str)\">'Line 1\\\nLine 2';", "goodExample": "const foo = `Line 1\nLine 2`;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-negated-condition": { "name": "no-negated-condition", "value": "off", "description": "禁止 if 里有否定的表达式", "reason": "否定的表达式可以把逻辑表达的更清楚", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-nested-ternary": { "name": "no-nested-ternary", "value": "off", "description": "禁止使用嵌套的三元表达式，比如 a ? b : c ? d : e", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-new": { "name": "no-new", "value": "off", "description": "禁止直接 new 一个类而不赋值", "reason": "new 应该作为创建一个类的实例的方法，所以不能不赋值", "badExample": "eslint(no-new)\">new Foo();", "goodExample": "const foo = new foo();", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-new-func": { "name": "no-new-func", "value": "error", "description": "禁止使用 new Function", "reason": "这和 eval 是等价的", "badExample": "const foo = eslint(no-new-func)\">new Function('a', 'b', 'return a + b');", "goodExample": "const foo = function (a, b) {\n return a + b;\n};", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-new-object": { "name": "no-new-object", "value": "error", "description": "禁止直接 new Object", "reason": "", "badExample": "const foo = eslint(no-new-object)\">new Object();", "goodExample": "const foo = {};", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-new-symbol": { "name": "no-new-symbol", "value": "error", "description": "禁止使用 new 来生成 Symbol", "reason": "", "badExample": "const foo = new eslint(no-new-symbol)\">Symbol('foo');", "goodExample": "const foo = Symbol('foo');", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-new-wrappers": { "name": "no-new-wrappers", "value": "error", "description": "禁止使用 new 来生成 String, Number 或 Boolean", "reason": "", "badExample": "const s = eslint(no-new-wrappers)\">new String('foo');\nconst n = eslint(no-new-wrappers)\">new Number(1);\nconst b = eslint(no-new-wrappers)\">new Boolean(true);", "goodExample": "const s = String(someValue);\nconst n = Number(someValue);\nconst b = Boolean(someValue);", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-obj-calls": { "name": "no-obj-calls", "value": "error", "description": "禁止将 Math, JSON 或 Reflect 直接作为函数调用", "reason": "", "badExample": "const foo = eslint(no-obj-calls)\">Math();\nconst bar = eslint(no-obj-calls)\">JSON();\nconst baz = eslint(no-obj-calls)\">Reflect();", "goodExample": "const foo = Math.random();\nconst bar = JSON.parse('{}');\nconst baz = Reflect.get({ x: 1, y: 2 }, 'x');", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-octal": { "name": "no-octal", "value": "off", "description": "禁止使用 0 开头的数字表示八进制数", "reason": "编译阶段就会报错了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-octal-escape": { "name": "no-octal-escape", "value": "off", "description": "禁止使用八进制的转义符", "reason": "编译阶段就会报错了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-param-reassign": { "name": "no-param-reassign", "value": "error", "description": "禁止对函数的参数重新赋值", "reason": "", "badExample": "function foo(bar) {\n eslint(no-param-reassign)\">bar = bar || '';\n}", "goodExample": "function foo(bar_) {\n bar = bar_ || '';\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-plusplus": { "name": "no-plusplus", "value": "off", "description": "禁止使用 ++ 或 --", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-promise-executor-return": { "name": "no-promise-executor-return", "value": "error", "description": "禁止在 Promise 的回调函数中直接 return", "reason": "", "badExample": "new Promise((resolve, reject) => {\n if (someCondition) {\n eslint(no-promise-executor-return)\">return defaultResult;\n }\n getSomething((err, result) => {\n if (err) {\n reject(err);\n } else {\n resolve(result);\n }\n });\n});", "goodExample": "new Promise((resolve, reject) => {\n if (someCondition) {\n resolve(defaultResult);\n return;\n }\n getSomething((err, result) => {\n if (err) {\n reject(err);\n } else {\n resolve(result);\n }\n });\n});", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-proto": { "name": "no-proto", "value": "error", "description": "禁止使用 __proto__", "reason": "__proto__ 是已废弃的语法", "badExample": "const foo = eslint(no-proto)\">bar.__proto__;\neslint(no-proto)\">bar.__proto__ = baz;", "goodExample": "const foo = Object.getPrototypeOf(bar);\nObject.setPrototypeOf(bar, baz);", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-prototype-builtins": { "name": "no-prototype-builtins", "value": "off", "description": "禁止使用 hasOwnProperty, isPrototypeOf 或 propertyIsEnumerable", "reason": "hasOwnProperty 比较常用", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-redeclare": { "name": "no-redeclare", "value": "off", "description": "禁止重复定义变量", "reason": "禁用 var 之后，编译阶段就会报错了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-regex-spaces": { "name": "no-regex-spaces", "value": "error", "description": "禁止在正则表达式中出现连续的空格", "reason": "", "badExample": "const reg1 = eslint(no-regex-spaces)\">/foo bar/;\nconst reg2 = eslint(no-regex-spaces)\">new RegExp('foo bar');", "goodExample": "const reg1 = /foo {3}bar/;\nconst reg2 = new RegExp('foo {3}bar');", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-restricted-exports": { "name": "no-restricted-exports", "value": "off", "description": "禁止导出指定的变量名", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-restricted-globals": { "name": "no-restricted-globals", "value": "off", "description": "禁止使用指定的全局变量", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-restricted-imports": { "name": "no-restricted-imports", "value": "off", "description": "禁止导入指定的模块", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-restricted-properties": { "name": "no-restricted-properties", "value": "off", "description": "禁止使用指定的对象属性", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-restricted-syntax": { "name": "no-restricted-syntax", "value": "off", "description": "禁止使用指定的语法", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-return-assign": { "name": "no-return-assign", "value": ["error", "always"], "description": "禁止在 return 语句里赋值", "reason": "", "badExample": "function foo() {\n eslint(no-return-assign)\">return (bar = 1);\n}", "goodExample": "function foo() {\n bar = 1;\n return bar;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-return-await": { "name": "no-return-await", "value": "off", "description": "禁止在 return 语句里使用 await", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-script-url": { "name": "no-script-url", "value": "off", "description": "禁止出现 location.href = 'javascript:void(0)';", "reason": "有些场景下还是需要用到这个", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-self-assign": { "name": "no-self-assign", "value": "error", "description": "禁止将自己赋值给自己", "reason": "", "badExample": "foo = eslint(no-self-assign)\">foo;", "goodExample": "foo = bar;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-self-compare": { "name": "no-self-compare", "value": "error", "description": "禁止将自己与自己比较", "reason": "", "badExample": "if (eslint(no-self-compare)\">foo === foo) {\n}\nif (eslint(no-self-compare)\">NaN === NaN) {\n}", "goodExample": "if (foo === bar) {\n}\nif (isNaN(foo)) {\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-sequences": { "name": "no-sequences", "value": "error", "description": "禁止使用逗号操作符", "reason": "", "badExample": "foo = doSomething()eslint(no-sequences)\">, 1;", "goodExample": "doSomething();\nfoo = 1;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-setter-return": { "name": "no-setter-return", "value": "error", "description": "禁止 setter 有返回值", "reason": "", "badExample": "const foo = {\n set bar(value) {\n this.barValue = 'bar ' + value;\n eslint(no-setter-return)\">return this.barValue;\n },\n};", "goodExample": "const foo = {\n set bar(value) {\n this.barValue = 'bar ' + value;\n },\n};", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-shadow": { "name": "no-shadow", "value": "off", "description": "禁止变量名与上层作用域内的已定义的变量重复", "reason": "很多时候函数的形参和传参是同名的", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-shadow-restricted-names": { "name": "no-shadow-restricted-names", "value": "error", "description": "禁止使用保留字作为变量名", "reason": "", "badExample": "const eslint(no-shadow-restricted-names)\">undefined = 1;\nfunction foo(eslint(no-shadow-restricted-names)\">NaN) {}\nfunction eslint(no-shadow-restricted-names)\">Infinity() {}", "goodExample": "console.log(undefined);\nconsole.log(NaN);\nconsole.log(Infinity);", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-sparse-arrays": { "name": "no-sparse-arrays", "value": "error", "description": "禁止在数组中出现连续的逗号", "reason": "", "badExample": "const foo = eslint(no-sparse-arrays)\">[1, 2, , 3];", "goodExample": "const foo = [1, 2, 3];", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-template-curly-in-string": { "name": "no-template-curly-in-string", "value": "off", "description": "禁止在普通字符串中出现模版字符串里的变量形式", "reason": "", "badExample": "const foo = eslint(no-template-curly-in-string)\">'Hello ${bar}';", "goodExample": "const foo = 'Hello {bar}';", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-ternary": { "name": "no-ternary", "value": "off", "description": "禁止使用三元表达式", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-this-before-super": { "name": "no-this-before-super", "value": "error", "description": "禁止在 super 被调用之前使用 this 或 super", "reason": "", "badExample": "class Foo extends Bar {\n constructor() {\n eslint(no-this-before-super)\">this.foo = 1;\n super();\n }\n}", "goodExample": "class Foo extends Bar {\n constructor() {\n super();\n this.foo = 1;\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-throw-literal": { "name": "no-throw-literal", "value": "error", "description": "禁止 throw 字面量，必须 throw 一个 Error 对象", "reason": "", "badExample": "eslint(no-throw-literal)\">throw 'foo';\neslint(no-throw-literal)\">throw 1;", "goodExample": "throw new Error('foo');", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-undef": { "name": "no-undef", "value": "error", "description": "禁止使用未定义的变量", "reason": "", "badExample": "eslieslint(no-undef)\">nt(no-undef)\">foo(bar);", "goodExample": "function foo() {}\nconst bar = 1;\nfoo(bar);\n\nif (typeof baz === 'number') {\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-undef-init": { "name": "no-undef-init", "value": "error", "description": "禁止将 undefined 赋值给变量", "reason": "", "badExample": "let eslint(no-undef-init)\">foo = undefined;", "goodExample": "let foo;", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-undefined": { "name": "no-undefined", "value": "off", "description": "禁止使用 undefined", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-underscore-dangle": { "name": "no-underscore-dangle", "value": "off", "description": "禁止变量名出现下划线", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unmodified-loop-condition": { "name": "no-unmodified-loop-condition", "value": "error", "description": "循环内必须对循环条件中的变量有修改", "reason": "", "badExample": "let foo = 10;\nwhile (eslint(no-unmodified-loop-condition)\">foo) {\n console.log(foo);\n}", "goodExample": "let foo = 10;\nwhile (foo) {\n console.log(foo);\n foo--;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unneeded-ternary": { "name": "no-unneeded-ternary", "value": "off", "description": "必须使用 !a 替代 a ? false : true", "reason": "后者表达的更清晰", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unreachable": { "name": "no-unreachable", "value": "error", "description": "禁止在 return, throw, break 或 continue 之后还有代码", "reason": "", "badExample": "function foo() {\n return;\n eslint(no-unreachable)\">const bar = 1;\n}", "goodExample": "function foo() {\n return;\n // const bar = 1;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unreachable-loop": { "name": "no-unreachable-loop", "value": "error", "description": "禁止在第一轮循环时就一定会退出循环的情况出现", "reason": "", "badExample": "eslint(no-unreachable-loop)\">for (foo of bar) {\n if (foo.id === id) {\n doSomething(foo);\n }\n break;\n}", "goodExample": "for (foo of bar) {\n if (foo.id === id) {\n doSomething(foo);\n break;\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unsafe-finally": { "name": "no-unsafe-finally", "value": "error", "description": "禁止在 finally 中出现 return, throw, break 或 continue", "reason": "finally 中的语句会在 try 之前执行", "badExample": "function foo() {\n try {\n return 1;\n } finally {\n // finally 会在 try 之前执行，故会 return 2\n eslint(no-unsafe-finally)\">return 2;\n }\n}", "goodExample": "function foo() {\n try {\n return 1;\n } finally {\n console.log(2);\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unsafe-negation": { "name": "no-unsafe-negation", "value": "error", "description": "禁止在 in 或 instanceof 操作符的左侧变量前使用感叹号", "reason": "", "badExample": "if (eslint(no-unsafe-negation)\">!key in object) {\n}\nif (eslint(no-unsafe-negation)\">!obj instanceof SomeClass) {\n}", "goodExample": "if (!(key in object)) {\n}\nif (!(obj instanceof SomeClass)) {\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unused-expressions": { "name": "no-unused-expressions", "value": ["error", { "allowShortCircuit": true, "allowTernary": true, "allowTaggedTemplates": true }], "description": "禁止无用的表达式", "reason": "", "badExample": "eslint(no-unused-expressions)\">1;\neslint(no-unused-expressions)\">foo;\neslint(no-unused-expressions)\">('foo');\neslint(no-unused-expressions)\">foo && bar;\neslint(no-unused-expressions)\">foo || bar;\neslint(no-unused-expressions)\">foo ? bar : baz;\neslint(no-unused-expressions)\">`bar`;", "goodExample": "'use strict';\nfoo && bar();\nfoo || bar();\nfoo ? bar() : baz();\nfoo`bar`;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unused-labels": { "name": "no-unused-labels", "value": "off", "description": "禁止出现没用到的 label", "reason": "已经禁止使用 label 了", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-unused-vars": { "name": "no-unused-vars", "value": ["error", { "vars": "all", "args": "none", "ignoreRestSiblings": false, "caughtErrors": "none" }], "description": "已定义的变量必须使用", "reason": "", "badExample": "let foo = 1;\neslint(no-unused-vars)\">foo = 2;\n\nfunction eslint(no-unused-vars)\">bar(baz) {}\n\nconst { eslint(neslint(no-unused-vars)\">o-unused-vars)\">baz, ...rest } = data;", "goodExample": "let foo = 1;\nconsole.log(foo);\n\nfunction bar(baz) {}\nbar();\n\nconst { baz, ...rest } = data;\nconsole.log(baz, rest);\n\ntry {\n} catch (e) {}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-use-before-define": { "name": "no-use-before-define", "value": ["error", { "variables": false, "functions": false, "classes": false }], "description": "变量必须先定义后使用", "reason": "", "badExample": "console.log(eslint(no-use-before-define)\">foo);\nconst foo = 1;\n\nnew eslint(no-use-before-define)\">Baz();\nclass Baz {}", "goodExample": "(() => {\n console.log(foo);\n})();\nconst foo = 1;\nconsole.log(foo);\n\nbar();\nfunction bar() {}\n\n(() => {\n new Baz();\n})();\nclass Baz {}\nnew Baz();", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-backreference": { "name": "no-useless-backreference", "value": "error", "description": "禁止正则表达式中出现无用的回溯引用", "reason": "某些回溯引用语法上没问题，但是会永远匹配到空字符串", "badExample": "eslint(no-useless-backreference)\">/^(?:(a)|\\1b)$/; // reference to (a) into another alternative", "goodExample": "/^(?:(a)|(b)\\2)$/; // reference to (b)", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-call": { "name": "no-useless-call", "value": "error", "description": "禁止出现没必要的 call 或 apply", "reason": "", "badExample": "eslint(no-useless-call)\">foo.call(null, 1, 2, 3); // foo(1, 2, 3)\neslint(no-useless-call)\">foo.apply(null, [1, 2, 3]); // foo(1, 2, 3)\n\neslint(no-useless-call)\">foo.bar.call(foo, 1, 2, 3); // foo.bar(1, 2, 3);\neslint(no-useless-call)\">foo.bar.apply(foo, [1, 2, 3]); // foo.bar(1, 2, 3);", "goodExample": "foo.call(bar, 1, 2, 3);\nfoo.apply(bar, [1, 2, 3]);\n\nfoo.bar.call(baz, 1, 2, 3);\nfoo.bar.apply(baz, [1, 2, 3]);", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-catch": { "name": "no-useless-catch", "value": "error", "description": "禁止在 catch 中仅仅只是把错误 throw 出去", "reason": "这样的 catch 是没有意义的，等价于直接执行 try 里的代码", "badExample": "eslint(no-useless-catch)\">try {\n doSomethingThatMightThrow();\n} catch (e) {\n throw e;\n}", "goodExample": "doSomethingThatMightThrow();\n\ntry {\n doSomethingThatMightThrow();\n} catch (e) {\n doSomethingBeforeRethrow();\n throw e;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-computed-key": { "name": "no-useless-computed-key", "value": "error", "description": "禁止出现没必要的计算键名", "reason": "", "badExample": "const foo = {\n eslint(no-useless-computed-key)\">['1']: 1,\n eslint(no-useless-computed-key)\">['bar']: 'bar',\n};", "goodExample": "const foo = {\n 1: 1,\n bar: 'bar',\n};", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-concat": { "name": "no-useless-concat", "value": "error", "description": "禁止出现没必要的字符串连接", "reason": "", "badExample": "const foo = 'f' eslint(no-useless-concat)\">+ 'oo';\nconst bar = `b` eslint(no-useless-concat)\">+ `ar`;", "goodExample": "const foo = 'fo';\nconst bar = 1 + `ar`;", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-constructor": { "name": "no-useless-constructor", "value": "error", "description": "禁止出现没必要的 constructor", "reason": "", "badExample": "class Foo {\n eslint(no-useless-constructor)\">constructor() {}\n}\nclass Bar extends Foo {\n eslint(no-useless-constructor)\">constructor(...args) {\n super(...args);\n }\n}", "goodExample": "class Foo {\n constructor() {\n doSomething();\n }\n}\nclass Bar extends Foo {\n constructor(...args) {\n super(...args);\n doSomething();\n }\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-escape": { "name": "no-useless-escape", "value": "off", "description": "禁止出现没必要的转义", "reason": "转义可以使代码更易懂", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-rename": { "name": "no-useless-rename", "value": "error", "description": "禁止解构赋值时出现同样名字的的重命名，比如 let { foo: foo } = bar;", "reason": "", "badExample": "import { eslint(no-useless-rename)\">foo as foo } from 'foo';\nconst bar = 1;\nexport { eslint(no-useless-rename)\">bar as bar };\nlet { eslint(no-useless-rename)\">baz: baz } = foo;", "goodExample": "import { foo } from 'foo';\nconst bar = 1;\nexport { bar };\nlet { baz } = foo;", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-useless-return": { "name": "no-useless-return", "value": "off", "description": "禁止没必要的 return", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-var": { "name": "no-var", "value": "error", "description": "禁止使用 var", "reason": "", "badExample": "eslint(no-var)\">var foo = 1;", "goodExample": "let foo = 1;\nconst bar = 2;", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-void": { "name": "no-void", "value": "error", "description": "禁止使用 void", "reason": "", "badExample": "function foo() {\n return eslint(no-void)\">void 0;\n}", "goodExample": "function foo() {\n return;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-warning-comments": { "name": "no-warning-comments", "value": "off", "description": "禁止注释中出现 TODO 和 FIXME", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "no-with": { "name": "no-with", "value": "off", "description": "禁止使用 with", "reason": "编译阶段就会报错了", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "object-shorthand": { "name": "object-shorthand", "value": "off", "description": "必须使用 a = {b} 而不是 a = {b: b}", "reason": "有时后者可以使代码结构更清晰", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "one-var": { "name": "one-var", "value": ["error", "never"], "description": "禁止变量申明时用逗号一次申明多个", "reason": "", "badExample": "eslint(one-var)\">let foo, bar;\neslint(one-var)\">const baz = 1,\n qux = 2;", "goodExample": "let foo;\nlet bar;\nconst baz = 1;\nconst qux = 2;", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "operator-assignment": { "name": "operator-assignment", "value": "off", "description": "必须使用 x = x + y 而不是 x += y", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "padding-line-between-statements": { "name": "padding-line-between-statements", "value": "off", "description": "限制语句之间的空行规则，比如变量定义完之后必须要空行", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-const": { "name": "prefer-const", "value": "off", "description": "申明后不再被修改的变量必须使用 const 来申明", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-destructuring": { "name": "prefer-destructuring", "value": "off", "description": "必须使用解构赋值", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-exponentiation-operator": { "name": "prefer-exponentiation-operator", "value": "off", "description": "使用 ES2016 的语法 ** 替代 Math.pow", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-named-capture-group": { "name": "prefer-named-capture-group", "value": "off", "description": "使用 ES2018 中的正则表达式命名组", "reason": "正则表达式已经较难理解了，没必要强制加上命名组", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-numeric-literals": { "name": "prefer-numeric-literals", "value": "off", "description": "必须使用 0b11111011 而不是 parseInt()", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-object-spread": { "name": "prefer-object-spread", "value": "error", "description": "必须使用 ... 而不是 Object.assign，除非 Object.assign 的第一个参数是一个变量", "reason": "", "badExample": "const foo = eslint(prefer-object-spread)\">Object.assign({}, bar);", "goodExample": "const foo = { ...bar };\n\n// 第一个参数为变量时允许使用 Object.assign\nObject.assign(foo, baz);", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-promise-reject-errors": { "name": "prefer-promise-reject-errors", "value": "error", "description": "Promise 的 reject 中必须传入 Error 对象，而不是字面量", "reason": "", "badExample": "eslint(prefer-promise-reject-errors)\">Promise.reject('foo');\n\nnew Promise((resolve, reject) => {\n eslint(prefer-promise-reject-errors)\">reject();\n});\n\nnew Promise((resolve, reject) => {\n eslint(prefer-promise-reject-errors)\">reject('foo');\n});", "goodExample": "Promise.reject(new Error('foo'));\n\nnew Promise((resolve, reject) => {\n reject(new Error('foo'));\n});", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-regex-literals": { "name": "prefer-regex-literals", "value": "error", "description": "优先使用正则表达式字面量，而不是 RegExp 构造函数", "reason": "", "badExample": "eslint(prefer-regex-literals)\">new RegExp('abc');\neslint(prefer-regex-literals)\">new RegExp('\\\\.', 'g');", "goodExample": "/abc/;\n/\\./g;\nnew RegExp(prefix + 'abc');", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-rest-params": { "name": "prefer-rest-params", "value": "off", "description": "必须使用 ...args 而不是 arguments", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-spread": { "name": "prefer-spread", "value": "off", "description": "必须使用 ... 而不是 apply，比如 foo(...args)", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "prefer-template": { "name": "prefer-template", "value": "off", "description": "必须使用模版字符串而不是字符串连接", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "radix": { "name": "radix", "value": "off", "description": "parseInt 必须传入第二个参数", "reason": "", "badExample": "const foo = eslint(radix)\">parseInt('071'); // 57", "goodExample": "const foo = parseInt('071', 10); // 71", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "require-atomic-updates": { "name": "require-atomic-updates", "value": "off", "description": "禁止将 await 或 yield 的结果做为运算符的后面项", "reason": "这样会导致不符合预期的结果\nhttps://github.com/eslint/eslint/issues/11899\n在上面 issue 修复之前，关闭此规则", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "require-await": { "name": "require-await", "value": "off", "description": "async 函数中必须存在 await 语句", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "require-unicode-regexp": { "name": "require-unicode-regexp", "value": "off", "description": "正则表达式中必须要加上 u 标志", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "require-yield": { "name": "require-yield", "value": "error", "description": "generator 函数内必须有 yield", "reason": "", "badExample": "eslint(require-yield)\">function* foo() {\n return 1;\n}", "goodExample": "function* foo() {\n yield 1;\n return 2;\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "sort-imports": { "name": "sort-imports", "value": "off", "description": "导入必须按规则排序", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "sort-keys": { "name": "sort-keys", "value": "off", "description": "对象字面量的键名必须排好序", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "sort-vars": { "name": "sort-vars", "value": "off", "description": "变量申明必须排好序", "reason": "", "badExample": "", "goodExample": "", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "spaced-comment": { "name": "spaced-comment", "value": ["error", "always", { "block": { "exceptions": ["*"], "balanced": true } }], "description": "注释的斜线或 * 后必须有空格", "reason": "", "badExample": "eslint(spaced-comment)\">//foo\neslint(spaced-comment)\">/*bar */\neslint(spaced-comment)\">/**baz */", "goodExample": "// foo\n/* bar */\n/** baz */", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "strict": { "name": "strict", "value": ["error", "never"], "description": "禁止使用 'strict';", "reason": "", "badExample": "eslint(strict)\">'use strict';\nfunction foo() {\n eslint(strict)\">'use strict';\n}", "goodExample": "function foo() {}", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false }, "symbol-description": { "name": "symbol-description", "value": "error", "description": "创建 Symbol 时必须传入参数", "reason": "", "badExample": "const foo = eslint(symbol-description)\">Symbol();", "goodExample": "const foo = Symbol('foo');", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "use-isnan": { "name": "use-isnan", "value": "error", "description": "必须使用 isNaN(foo) 而不是 foo === NaN", "reason": "", "badExample": "if (eslint(use-isnan)\">foo === NaN) {\n}", "goodExample": "if (isNaN(foo)) {\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "valid-typeof": { "name": "valid-typeof", "value": "error", "description": "typeof 表达式比较的对象必须是 'undefined', 'object', 'boolean', 'number', 'string', 'function', 'symbol', 或 'bigint'", "reason": "", "badExample": "if (typeof foo === eslint(valid-typeof)\">'numbe') {\n}", "goodExample": "if (typeof foo === 'number') {\n}", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "vars-on-top": { "name": "vars-on-top", "value": "off", "description": "var 必须在作用域的最前面", "reason": "", "badExample": "", "goodExample": "", "fixable": false, "extendsBaseRule": "", "requiresTypeChecking": false }, "yoda": { "name": "yoda", "value": ["error", "never", { "onlyEquality": true }], "description": "必须使用 if (foo === 5) 而不是 if (5 === foo)", "reason": "", "badExample": "if (eslint(yoda)\">1 === foo) {\n}", "goodExample": "if (foo === 1) {\n}\nif (1 < foo) {\n}\nif (1 < foo && foo < 10) {\n}", "fixable": true, "extendsBaseRule": "", "requiresTypeChecking": false } }