{
"accessor-pairs": {
"good": "// good setter 有对应的 getter\nconst foo = {\n set bar(value) {\n this.barValue = 'bar ' + value;\n },\n get bar() {\n return this.barValue;\n }\n};\n\n// good getter 可以没有对应的 setter\nconst bar = {\n get foo() {\n return this.fooValue;\n }\n};",
"bad": "// bad 有 setter 却没有对应的 getter\nconst foo = {\n set bar(value) {\n return 'bar ' + value;\n }\n};"
},
"array-callback-return": {
"good": "// good 数组的 map 方法的回调函数有返回值\r\nlet foo = [1, 2, 3].map((num) => {\r\n return num * num;\r\n});",
"bad": "// bad 数组的 map 方法的回调函数缺少返回值\r\nlet foo = [1, 2, 3].map((num) => {\r\n console.log(num * num);\r\n});"
},
"block-scoped-var": {
"good": "// good 使用 let 或 const 定义变量，不在 if 中定义变量\nlet bar;\nif (foo) {\n bar = 1;\n}\nconsole.log(bar);",
"bad": "// bad if 中定义的 var 在外面被使用了\nif (foo) {\n var bar = 1;\n}\nconsole.log(bar);"
},
"complexity": {
"good": "// good 单个函数的循环复杂度小于 20\r\nfunction foo() {\r\n let i;\r\n if (i === 1) console.log(i); if (i === 2) console.log(i); if (i === 3) console.log(i); if (i === 4) console.log(i); if (i === 5) console.log(i);\r\n if (i === 6) console.log(i); if (i === 7) console.log(i); if (i === 8) console.log(i); if (i === 9) console.log(i); if (i === 10) console.log(i);\r\n bar(i);\r\n}\r\nfunction bar(i) {\r\n if (i === 11) console.log(i); if (i === 12) console.log(i); if (i === 13) console.log(i); if (i === 14) console.log(i); if (i === 15) console.log(i);\r\n if (i === 16) console.log(i); if (i === 17) console.log(i); if (i === 18) console.log(i); if (i === 19) console.log(i); if (i === 20) console.log(i);\r\n}",
"bad": "// bad 循环复杂度超过了 20\r\nfunction foo() {\r\n let i;\r\n if (i === 1) console.log(i); if (i === 2) console.log(i); if (i === 3) console.log(i); if (i === 4) console.log(i); if (i === 5) console.log(i);\r\n if (i === 6) console.log(i); if (i === 7) console.log(i); if (i === 8) console.log(i); if (i === 9) console.log(i); if (i === 10) console.log(i);\r\n if (i === 11) console.log(i); if (i === 12) console.log(i); if (i === 13) console.log(i); if (i === 14) console.log(i); if (i === 15) console.log(i);\r\n if (i === 16) console.log(i); if (i === 17) console.log(i); if (i === 18) console.log(i); if (i === 19) console.log(i); if (i === 20) console.log(i);\r\n}"
},
"curly": {
"good": "// good if 后有 {\nif (foo) {\n console.log(foo);\n}\n// good 单行 if 可以不要 {}\nif (foo) console.log(foo);",
"bad": "// bad if 后没有 {\nif (foo)\n console.log(foo);"
},
"dot-location": {
"good": "// good 链式调用时，点号放在了行首\nfoo()\n .bar()\n .baz();",
"bad": "// bad 链式调用时，点号放在了行尾\nfoo().\n bar().\n baz();"
},
"eqeqeq": {
"good": "// good 使用了 ===\r\nif (foo === 1) {\r\n console.log('foo is 1');\r\n}\r\n\r\n// good 与 null 比较时，可以使用 == 或 !=\r\nif (foo == null) {\r\n console.log('foo is null or undefined');\r\n}",
"bad": "// bad 使用了 ==\r\nif (foo == 1) {\r\n console.log('foo is 1');\r\n}\r\n"
},
"for-direction": {
"good": "// good for 循环的方向正确\r\nfor (let i = 0; i < 10; i++) {\r\n // do something\r\n}",
"bad": "// bad for 循环的方向错误，循环无法结束\r\nfor (let i = 0; i < 10; i--) {\r\n // do something\r\n}"
},
"getter-return": {
"good": "// good getter 有返回值\nlet user = {\n get name() {\n return 'Alex';\n }\n};\nclass User {\n get name() {\n return this.name;\n }\n}",
"bad": "// bad getter 没有返回值，或返回空\nlet user = {\n get name() {\n // 无返回值\n }\n};\nclass User {\n get name() {\n // 返回空\n return;\n }\n}"
},
"no-compare-neg-zero": {
"good": "// good 不与负零比较，与零比较\nif (foo === 0) {\n // do something\n}",
"bad": "// bad 与负零比较\nif (foo === -0) {\n // do something\n}"
},
"no-cond-assign": {
"good": "// good 在测试表达式中使用 ===\nif (foo === 0) {\n // do something\n}\n\n// good 使用括号将测试表达式中的赋值语句包起来了\nif (bar === (foo = 0)) {\n // do something\n}",
"bad": "// bad 测试表达式中使用了赋值语句\n// 这可能是把 === 误写成了 =\nif (foo = 0) {\n // do something\n}"
},
"no-confusing-arrow": {
"good": "// good 使用圆括号或花括号\r\nlet x = foo => (a ? 1 : 2);\r\nlet y = foo => { return a ? 1 : 2 };",
"bad": "// bad 容易混淆的箭头函数和三元表达式\r\nlet x = foo => a ? 1 : 2;"
},
"no-constant-condition": {
"good": "// good 将常量作为循环条件判断中的测试表达式\nfor (;true;) {\n if (foo === 0) break;\n}\nwhile (true) {\n if (foo === 0) break;\n}",
"bad": "// bad 将常量作为分支条件判断中的测试表达式\r\nif (true) {\r\n console.log('true');\r\n}\r\nconst foo = 0 ? 'bar' : 'baz';"
},
"no-debugger": {
"good": "// good 开发过程中使用到了 debugger，提交代码之前注释掉，或删掉\r\nif (foo) {\r\n // debugger;\r\n}",
"bad": "// bad 使用到了 debugger\r\nif (foo) {\r\n debugger;\r\n}"
},
"no-dupe-args": {
"good": "// good 函数参数的参数名称各不相同\r\nfunction foo(a, b, c) {\r\n // do something\r\n}",
"bad": "// bad 函数参数中出现了重复名称的参数\r\nfunction foo(a, b, a) {\r\n // do something\r\n}"
},
"no-dupe-keys": {
"good": "// good 对象字面量中的键名各不相同\r\nlet foo = {\r\n bar: 1,\r\n baz: 2\r\n};",
"bad": "// bad 对象字面量中出现了重复名称的键名\r\nlet foo = {\r\n bar: 1,\r\n bar: 2\r\n};"
},
"no-duplicate-case": {
"good": "// good switch 语句中的各个 case 的测试表达式均不相同\r\nswitch (foo) {\r\n case 1: break;\r\n case 2: break;\r\n case 3: break;\r\n}",
"bad": "// bad switch 语句中出现了重复的测试表达式的 case\r\nswitch (foo) {\r\n case 1: break;\r\n case 2: break;\r\n case 1: break;\r\n}"
},
"no-empty": {
"good": "// good 空代码块中有注释\r\nif (foo) {\r\n // do something\r\n}",
"bad": "// bad 出现了空代码块\r\nif (foo) {\r\n}"
},
"no-empty-character-class": {
"good": "// good 正则表达式中的字符集不为空\r\nlet reg = /abc[a-z]/;",
"bad": "// bad 正则表达式中使用了空的字符集 []\r\nlet reg = /abc[]/;"
},
"no-ex-assign": {
"good": "// good catch 的第一个参数 error 没有被重新赋值了\r\ntry {\r\n // do something\r\n} catch (e) {\r\n console.error(e);\r\n}",
"bad": "// bad catch 的第一个参数 error 被重新赋值了\r\ntry {\r\n // do something\r\n} catch (e) {\r\n e = 10;\r\n}"
},
"no-extra-boolean-cast": {
"good": "// good 测试表达式中没必要使用 !! 或 Boolean\r\nif (foo) {\r\n // do something\r\n}",
"bad": "// bad 在测试表达式中使用了 !!\r\nif (!!foo) {\r\n // do something\r\n}\r\n\r\n// bad 在测试表达式中使用了 Boolean\r\nif (Boolean(foo)) {\r\n // do something\r\n}"
},
"no-extra-parens": {
"good": "// good 函数表达式中不使用多余的括号\r\nlet foo = function () { return 1 };\r\n\r\n// good 普通的表达式中允许出现多余的括号\r\nlet bar = (a * b) + c;",
"bad": "// bad 函数表达式中使用了多余的括号\r\nlet foo = (function () { return 1 });"
},
"no-extra-semi": {
"good": "// good 没有多余的分号\r\nlet foo = 1;\r\nfunction bar() {\r\n // do something\r\n}",
"bad": "// bad 出现了多余的分号\r\nlet foo = 1;;\r\nfunction bar() {\r\n // do something\r\n};"
},
"no-func-assign": {
"good": "// good 函数表达式可以被重新赋值\r\nlet foo = function() {\r\n // do something\r\n};\r\nfoo = 1;",
"bad": "// bad 函数声明被重新赋值了\r\nfunction foo() {\r\n // do something\r\n}\r\nfoo = 1;"
},
"no-implicit-coercion": {
"good": "// good 不使用 ~ 等难以理解的运算符\r\nlet b2 = foo.indexOf('.') !== -1;\r\nlet n = Number(foo);\r\nlet n2 = Number(foo);\r\nlet s = String(foo);\r\nfoo = String(foo);\r\n\r\n// good 可以使用 !!\r\nlet b = !!foo;",
"bad": "// bad 使用了 ~ 等难以理解的运算符\r\nlet b = ~foo.indexOf('.');\r\nlet n = +foo;\r\nlet n = 1 * foo;\r\nlet s = '' + foo;\r\nfoo += ``;"
},
"no-inner-declarations": {
"good": "// good if 代码块内使用函数表达式而不是函数声明\r\nif (foo) {\r\n let bar = function () {\r\n // do something\r\n };\r\n}",
"bad": "// bad if 代码块内出现了函数声明\r\nif (foo) {\r\n function bar() {\r\n // do something\r\n }\r\n}"
},
"no-invalid-regexp": {
"good": "// good 在 RegExp 构造函数使用合法的正则表达式\r\nlet reg1 = new RegExp('[a-z]');\r\nlet reg2 = new RegExp('.', 'g');",
"bad": "// bad 在 RegExp 构造函数中出现了非法的正则表达式\r\nlet reg1 = new RegExp('[');\r\nlet reg2 = new RegExp('.', 'z');"
},
"no-irregular-whitespace": {
"good": "// good 字符串、正则表达式或模版字符串中允许使用特殊空白符（全角空格）\r\nlet foo = ' ';\r\nlet bar = / /;\r\nlet baz = ` `;",
"bad": "// bad 使用了特殊空白符（全角空格）\r\nfunction foo() {\r\n // do something\r\n}"
},
"no-obj-calls": {
"good": "// good 正确的使用 Math, JSON 和 Reflect\r\nlet foo = Math.random();\r\nlet bar = JSON.parse('{}');\r\nlet baz = Reflect.get({ x: 1, y: 2 }, 'x');",
"bad": "// bad 将 Math, JSON 或 Reflect 直接作为函数调用了\r\nlet foo = Math();\r\nlet bar = JSON();\r\nlet baz = Reflect();"
},
"no-regex-spaces": {
"good": "// good 正则表达式中的连续空格使用一个空格加大括号来表示\nlet reg1 = /foo {3}bar/;\nlet reg2 = new RegExp('foo {3}bar');",
"bad": "// bad 正则表达式中出现了连续的空格\nlet reg1 = /foo bar/;\nlet reg2 = new RegExp('foo bar');"
},
"no-script-url": {
"good": "// good 不使用 javascript:void(0)\r\nlet foo = document.createElement('a');\r\na.href = '';\r\nfoo.addEventListener('click', (e) => {\r\n e.preventDefault();\r\n});",
"bad": "// bad 使用了 javascript:void(0)\r\nlet foo = document.createElement('a');\r\na.href = 'javascript:void(0)';"
},
"no-sparse-arrays": {
"good": "// good 在数组中正确的使用逗号\nlet foo = [1, 2, 3];",
"bad": "// bad 在数组中出现了连续的逗号\nlet foo = [1, 2,, 3];"
},
"no-template-curly-in-string": {
"good": "// good 普通字符串中不使用 es2015 的模版字符串的变量形式\nlet foo = 'Hello {bar}';",
"bad": "// bad 普通字符串中出现了 es2015 的模版字符串的变量形式\nlet foo = 'Hello ${bar}';"
},
"no-unexpected-multiline": {
"good": "// good 避免多行表达式\r\nlet foo = bar[1].forEach(baz);\r\n\r\n// good 使用分号分隔多行\r\nlet foo = bar;\r\n[1, 2, 3].forEach(baz);",
"bad": "// bad 出现了难以理解的多行表达式\r\nlet foo = bar\r\n[1, 2, 3].forEach(baz);"
},
"no-unreachable": {
"good": "// good return, throw, break 或 continue 之后没有代码\r\nfunction foo() {\r\n return;\r\n // let bar = 1;\r\n}",
"bad": "// bad return, throw, break 或 continue 之后还有代码\r\nfunction foo() {\r\n return;\r\n let bar = 1;\r\n}"
},
"no-unsafe-finally": {
"good": "// good finally 中不使用 return, throw, break 或 continue\r\nfunction foo() {\r\n try {\r\n return 1;\r\n } finally {\r\n console.log(2);\r\n }\r\n}\r\n",
"bad": "// bad finally 中使用了 return, throw, break 或 continue\r\nfunction foo() {\r\n try {\r\n return 1;\r\n } finally {\r\n // finally 会在 try 之前执行，故会 return 2\r\n return 2;\r\n }\r\n}\r\n"
},
"no-unsafe-negation": {
"good": "// good 在 in 或 instanceof 操作执行完之后再使用感叹号取非\r\nif (!(key in object)) {\r\n // do something\r\n}\r\nif (!(obj instanceof SomeClass)) {\r\n // do something\r\n}",
"bad": "// bad 在 in 或 instanceof 操作符的左侧使用感叹号\r\nif (!key in object) {\r\n // do something\r\n}\r\nif (!obj instanceof SomeClass) {\r\n // do something\r\n}"
},
"no-var": {
"good": "// good 可以使用 let 和 const\r\nlet foo = 1;\r\nconst bar = 2;",
"bad": "// bad 禁止使用 var\r\nvar foo = 1;"
},
"require-await": {
"good": "// good 允许 async function 中没有 await\r\nasync function foo() {\r\n console.log('foo');\r\n}",
"bad": ""
},
"space-before-function-paren": {
"good": "// good 函数名称后禁止有空格\r\nfunction foo() {\r\n console.log('foo');\r\n}\r\n\r\n// good 箭头函数的箭头前后必须有空格\r\nlet bar = () => {\r\n console.log('bar');\r\n};\r\n\r\n// good 匿名函数的 function 后面不限制有没有空格\r\nbar = function () {\r\n};\r\nbar = function() {\r\n};\r\n",
"bad": "// bad 函数名称后禁止有空格\r\nfunction foo () {\r\n console.log('foo');\r\n}\r\n\r\n// bad 箭头函数的箭头前后必须有空格\r\nlet bar = ()=>{\r\n console.log('bar');\r\n};\r\n"
},
"use-isnan": {
"good": "// good 使用 isNaN\r\nif (isNaN(foo)) {\r\n // do something\r\n}",
"bad": "// bad 使用了 foo === NaN\r\nif (foo === NaN) {\r\n // do something\r\n}"
},
"valid-typeof": {
"good": "// good typeof 表达式比较的对象是 'undefined', 'object', 'boolean', 'number', 'string', 'function' 或 'symbol'\nif (typeof foo === 'number') {\n // do something\n}",
"bad": "// bad typeof 表达式比较的对象是不可能得到的值\nif (typeof foo === 'numbe') {\n // do something\n}"
}
}