eslint-config-mlt
Version:
MLT ESLint 规则
2,104 lines • 256 kB
JSON
{
"accessor-pairs": {
"name": "accessor-pairs",
"value": ["error", { "setWithoutGet": true, "getWithoutSet": false }],
"description": "setter 必须有对应的 getter，getter 可以没有对应的 setter",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Getter is not present for setter &apos;bar&apos;.<br/><span class='eslint-error-rule-id'>eslint(accessor-pairs)</span>\"><span class=\"token keyword\">set</span> <span class=\"token function\">bar</span></mark><span class=\"token punctuation\">(</span><span class=\"token parameter\">value</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue <span class=\"token operator\">=</span> <span class=\"token string\">'bar '</span> <span class=\"token operator\">+</span> value<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">set</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">value</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue <span class=\"token operator\">=</span> <span class=\"token string\">'bar '</span> <span class=\"token operator\">+</span> value<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n <span class=\"token keyword\">get</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">get</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>fooValue<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"array-callback-return": {
"name": "array-callback-return",
"value": "error",
"description": "数组的方法除了 forEach 之外，回调函数必须有返回值",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">.</span><span class=\"token function\">map</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">num</span><span class=\"token punctuation\">)</span> <span class=\"token operator\"><mark class=\"eslint-error\" data-tip=\"Array.prototype.map() expects a return value from arrow function.<br/><span class='eslint-error-rule-id'>eslint(array-callback-return)</span>\">=></mark></span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>num <span class=\"token operator\">*</span> num<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">.</span><span class=\"token function\">map</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">num</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> num <span class=\"token operator\">*</span> num<span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"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": "<mark class=\"eslint-error\" data-tip=\"Function &apos;foo&apos; has a complexity of 21. Maximum allowed is 20.<br/><span class='eslint-error-rule-id'>eslint(complexity)</span>\"><span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">2</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">3</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">4</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">5</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">6</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">7</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">8</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">9</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">10</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">11</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">12</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">13</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">14</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">15</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">16</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">17</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">18</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">19</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">20</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span></mark>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">2</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">3</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">4</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">5</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">6</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">7</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">8</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">9</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">10</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">function</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">i</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">11</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">12</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">13</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">14</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">15</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">16</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">17</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">18</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">19</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">20</span><span class=\"token punctuation\">)</span> console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token keyword\">extends</span> <span class=\"token class-name\">Bar</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Expected to call &apos;super()&apos;.<br/><span class='eslint-error-rule-id'>eslint(constructor-super)</span>\"><span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token keyword\">extends</span> <span class=\"token class-name\">Bar</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">super</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Default clause should be the last clause.<br/><span class='eslint-error-rule-id'>eslint(default-case-last)</span>\"><span class=\"token keyword\">default</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span></mark>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">baz</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">baz</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">default</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"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": ["error", "always"],
"description": "必须使用 === 或 !==，禁止使用 == 或 !=",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\"><mark class=\"eslint-error\" data-tip=\"Expected &apos;===&apos; and instead saw &apos;==&apos;.<br/><span class='eslint-error-rule-id'>eslint(eqeqeq)</span>\">==</mark></span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>bar <span class=\"token operator\"><mark class=\"eslint-error\" data-tip=\"Expected &apos;!==&apos; and instead saw &apos;!=&apos;.<br/><span class='eslint-error-rule-id'>eslint(eqeqeq)</span>\">!=</mark></span> <span class=\"token keyword\">null</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">===</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>bar <span class=\"token operator\">!==</span> <span class=\"token keyword\">null</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"fixable": true,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"for-direction": {
"name": "for-direction",
"value": "error",
"description": "禁止方向错误的 for 循环",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"The update clause in this loop moves the variable in the wrong direction.<br/><span class='eslint-error-rule-id'>eslint(for-direction)</span>\"><span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span><span class=\"token keyword\">let</span> i <span class=\"token operator\">=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">;</span> i <span class=\"token operator\"><</span> <span class=\"token number\">10</span><span class=\"token punctuation\">;</span> i<span class=\"token operator\">--</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// do something</span>\n<span class=\"token punctuation\">}</span></mark>",
"goodExample": "<span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span><span class=\"token keyword\">let</span> i <span class=\"token operator\">=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">;</span> i <span class=\"token operator\"><</span> <span class=\"token number\">10</span><span class=\"token punctuation\">;</span> i<span class=\"token operator\">++</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// do something</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"func-name-matching": {
"name": "func-name-matching",
"value": ["error", "always", { "includeCommonJSModuleExports": false }],
"description": "函数赋值给变量的时候，函数名必须与变量名一致",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> <mark class=\"eslint-error\" data-tip=\"Function name `bar` should match variable name `foo`.<br/><span class='eslint-error-rule-id'>eslint(func-name-matching)</span>\"><span class=\"token function-variable function\">foo</span> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> <span class=\"token function-variable function\">foo</span> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> <span class=\"token function-variable function\">bar</span> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">const</span> user <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Expected to return a value in getter &apos;name&apos;.<br/><span class='eslint-error-rule-id'>eslint(getter-return)</span>\"><span class=\"token keyword\">get</span> <span class=\"token function\">name</span></mark><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// do something</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">class</span> <span class=\"token class-name\">User</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">get</span> <span class=\"token function\">name</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Expected to return a value in getter &apos;name&apos;.<br/><span class='eslint-error-rule-id'>eslint(getter-return)</span>\"><span class=\"token keyword\">return</span><span class=\"token punctuation\">;</span></mark>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">const</span> user <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">get</span> <span class=\"token function\">name</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token string\">'Alex'</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">class</span> <span class=\"token class-name\">User</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">get</span> <span class=\"token function\">name</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>name<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"grouped-accessor-pairs": {
"name": "grouped-accessor-pairs",
"value": "error",
"description": "setter 和 getter 必须写在一起",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">set</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">value</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue <span class=\"token operator\">=</span> <span class=\"token string\">'bar '</span> <span class=\"token operator\">+</span> value<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n baz<span class=\"token punctuation\">:</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span>\n <mark class=\"eslint-error\" data-tip=\"Accessor pair setter &apos;bar&apos; and getter &apos;bar&apos; should be grouped.<br/><span class='eslint-error-rule-id'>eslint(grouped-accessor-pairs)</span>\"><span class=\"token keyword\">get</span> <span class=\"token function\">bar</span></mark><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">set</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">value</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue <span class=\"token operator\">=</span> <span class=\"token string\">'bar '</span> <span class=\"token operator\">+</span> value<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n <span class=\"token keyword\">get</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n baz<span class=\"token punctuation\">:</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"guard-for-in": {
"name": "guard-for-in",
"value": "error",
"description": "for in 内部必须有 hasOwnProperty",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.<br/><span class='eslint-error-rule-id'>eslint(guard-for-in)</span>\"><span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span>key <span class=\"token keyword\">in</span> foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span>key<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span></mark>",
"goodExample": "<span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span>key <span class=\"token keyword\">in</span> foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token class-name\">Object</span><span class=\"token punctuation\">.</span>prototype<span class=\"token punctuation\">.</span><span class=\"token function\">hasOwnProperty</span><span class=\"token punctuation\">.</span><span class=\"token function\">call</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">,</span> key<span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span>key<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Blocks are nested too deeply (6). Maximum allowed is 5.<br/><span class='eslint-error-rule-id'>eslint(max-depth)</span>\"><span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token punctuation\">}</span></mark>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">baz</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">qux</span><span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Too many nested callbacks (4). Maximum allowed is 3.<br/><span class='eslint-error-rule-id'>eslint(max-nested-callbacks)</span>\"><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span></mark><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token keyword\">async</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">await</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">await</span> <span class=\"token function\">baz</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">await</span> <span class=\"token function\">qux</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"max-params": {
"name": "max-params",
"value": ["error", 3],
"description": "函数的参数禁止超过 3 个",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Function &apos;foo&apos; has too many parameters (4). Maximum allowed is 3.<br/><span class='eslint-error-rule-id'>eslint(max-params)</span>\"><span class=\"token keyword\">function</span> <span class=\"token function\">foo</span></mark><span class=\"token punctuation\">(</span><span class=\"token parameter\">a1<span class=\"token punctuation\">,</span> a2<span class=\"token punctuation\">,</span> a3<span class=\"token punctuation\">,</span> a4</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">a1<span class=\"token punctuation\">,</span> a2<span class=\"token punctuation\">,</span> a3</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">function</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token parameter\"><span class=\"token punctuation\">{</span> a1<span class=\"token punctuation\">,</span> a2<span class=\"token punctuation\">,</span> a3<span class=\"token punctuation\">,</span> a4 <span class=\"token punctuation\">}</span></span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">new</span> <span class=\"token class-name\"><mark class=\"eslint-error\" data-tip=\"A constructor name should not start with a lowercase letter.<br/><span class='eslint-error-rule-id'>eslint(new-cap)</span>\">foo</mark></span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">foo<span class=\"token punctuation\">.</span><mark class=\"eslint-error\" data-tip=\"A constructor name should not start with a lowercase letter.<br/><span class='eslint-error-rule-id'>eslint(new-cap)</span>\">bar</mark></span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">new</span> <span class=\"token class-name\">Foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">foo<span class=\"token punctuation\">.</span>Bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token function\">Foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"The array literal notation [] is preferable.<br/><span class='eslint-error-rule-id'>eslint(no-array-constructor)</span>\"><span class=\"token function\">Array</span><span class=\"token punctuation\">(</span><span class=\"token number\">0</span><span class=\"token punctuation\">,</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span> <span class=\"token comment\">// [0, 1, 2]</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"The array literal notation [] is preferable.<br/><span class='eslint-error-rule-id'>eslint(no-array-constructor)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">Array</span><span class=\"token punctuation\">(</span><span class=\"token number\">0</span><span class=\"token punctuation\">,</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span> <span class=\"token comment\">// [0, 1, 2]</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">[</span><span class=\"token number\">0</span><span class=\"token punctuation\">,</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">;</span>\n<span class=\"token function\">Array</span><span class=\"token punctuation\">(</span><span class=\"token number\">3</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// [empty × 3]</span>\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">Array</span><span class=\"token punctuation\">(</span><span class=\"token number\">3</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// [empty × 3]</span>\n<span class=\"token function\">Array</span><span class=\"token punctuation\">(</span><span class=\"token number\">3</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">.</span><span class=\"token function\">fill</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// [\"foo\", \"foo\", \"foo\"]</span>\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">Array</span><span class=\"token punctuation\">(</span><span class=\"token number\">3</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">.</span><span class=\"token function\">fill</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// [\"foo\", \"foo\", \"foo\"]</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-async-promise-executor": {
"name": "no-async-promise-executor",
"value": "error",
"description": "禁止将 async 函数做为 new Promise 的回调函数",
"reason": "出现这种情况时，一般不需要使用 new Promise 实现异步了",
"badExample": "<span class=\"token keyword\">new</span> <span class=\"token class-name\">Promise</span><span class=\"token punctuation\">(</span><span class=\"token keyword\"><mark class=\"eslint-error\" data-tip=\"Promise executor functions should not be async.<br/><span class='eslint-error-rule-id'>eslint(no-async-promise-executor)</span>\">async</mark></span> <span class=\"token punctuation\">(</span><span class=\"token parameter\">resolve</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">setTimeout</span><span class=\"token punctuation\">(</span>resolve<span class=\"token punctuation\">,</span> <span class=\"token number\">1000</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">new</span> <span class=\"token class-name\">Promise</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">resolve</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">setTimeout</span><span class=\"token punctuation\">(</span>resolve<span class=\"token punctuation\">,</span> <span class=\"token number\">1000</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">n</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>n <span class=\"token operator\"><=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n <mark class=\"eslint-error\" data-tip=\"Avoid arguments.callee.<br/><span class='eslint-error-rule-id'>eslint(no-caller)</span>\">arguments<span class=\"token punctuation\">.</span><span class=\"token function\">callee</span></mark><span class=\"token punctuation\">(</span>n <span class=\"token operator\">-</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">n</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>n <span class=\"token operator\"><=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span>n <span class=\"token operator\">-</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-case-declarations": {
"name": "no-case-declarations",
"value": "error",
"description": "switch 的 case 内有变量定义的时候，必须使用大括号将 case 内变成一个代码块",
"reason": "",
"badExample": "<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <mark class=\"eslint-error\" data-tip=\"Unexpected lexical declaration in case block.<br/><span class='eslint-error-rule-id'>eslint(no-case-declarations)</span>\"><span class=\"token keyword\">const</span> x <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span></mark>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">const</span> x <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-class-assign": {
"name": "no-class-assign",
"value": "error",
"description": "禁止对已定义的 class 重新赋值",
"reason": "",
"badExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n<mark class=\"eslint-error\" data-tip=\"&apos;Foo&apos; is a class.<br/><span class='eslint-error-rule-id'>eslint(no-class-assign)</span>\">Foo</mark> <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-compare-neg-zero": {
"name": "no-compare-neg-zero",
"value": "error",
"description": "禁止与负零进行比较",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Do not use the &apos;===&apos; operator to compare against -0.<br/><span class='eslint-error-rule-id'>eslint(no-compare-neg-zero)</span>\">foo <span class=\"token operator\">===</span> <span class=\"token operator\">-</span><span class=\"token number\">0</span></mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">===</span> <span class=\"token number\">0</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-cond-assign": {
"name": "no-cond-assign",
"value": ["error", "except-parens"],
"description": "禁止在测试表达式中使用赋值语句，除非这个赋值语句被括号包起来了",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Expected a conditional expression and instead saw an assignment.<br/><span class='eslint-error-rule-id'>eslint(no-cond-assign)</span>\">foo <span class=\"token operator\">=</span> <span class=\"token number\">0</span></mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">===</span> <span class=\"token number\">0</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>bar <span class=\"token operator\">===</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<mark class=\"eslint-error\" data-tip=\"&apos;foo&apos; is constant.<br/><span class='eslint-error-rule-id'>eslint(no-const-assign)</span>\">foo</mark> <span class=\"token operator\">=</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">let</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\nfoo <span class=\"token operator\">=</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span><span class=\"token keyword\">const</span> bar <span class=\"token keyword\">in</span> <span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-constant-condition": {
"name": "no-constant-condition",
"value": ["error", { "checkLoops": false }],
"description": "禁止将常量作为分支条件判断中的测试表达式，但允许作为循环条件判断中的测试表达式",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\"><mark class=\"eslint-error\" data-tip=\"Unexpected constant condition.<br/><span class='eslint-error-rule-id'>eslint(no-constant-condition)</span>\">true</mark></span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token number\"><mark class=\"eslint-error\" data-tip=\"Unexpected constant condition.<br/><span class='eslint-error-rule-id'>eslint(no-constant-condition)</span>\">0</mark></span> <span class=\"token operator\">?</span> <span class=\"token string\">'bar'</span> <span class=\"token punctuation\">:</span> <span class=\"token string\">'baz'</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">;</span> <span class=\"token boolean\">true</span><span class=\"token punctuation\">;</span> <span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">===</span> <span class=\"token number\">0</span><span class=\"token punctuation\">)</span> <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">while</span> <span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">===</span> <span class=\"token number\">0</span><span class=\"token punctuation\">)</span> <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-constructor-return": {
"name": "no-constructor-return",
"value": "error",
"description": "禁止在构造函数中返回值",
"reason": "",
"badExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">bar</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>bar <span class=\"token operator\">=</span> bar<span class=\"token punctuation\">;</span>\n <mark class=\"eslint-error\" data-tip=\"Unexpected return statement in constructor.<br/><span class='eslint-error-rule-id'>eslint(no-constructor-return)</span>\"><span class=\"token keyword\">return</span> bar<span class=\"token punctuation\">;</span></mark>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">bar</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token operator\">!</span>bar<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>bar <span class=\"token operator\">=</span> bar<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Unexpected &apos;debugger&apos; statement.<br/><span class='eslint-error-rule-id'>eslint(no-debugger)</span>\"><span class=\"token keyword\">debugger</span><span class=\"token punctuation\">;</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// debugger;</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n <mark class=\"eslint-error\" data-tip=\"Duplicate name &apos;bar&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-dupe-class-members)</span>\"><span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n <span class=\"token function\">baz</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-dupe-else-if": {
"name": "no-dupe-else-if",
"value": "error",
"description": "禁止 if else 的条件判断中出现重复的条件",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span> <span class=\"token keyword\">else</span> <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain.<br/><span class='eslint-error-rule-id'>eslint(no-dupe-else-if)</span>\">foo</mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span> <span class=\"token keyword\">else</span> <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-dupe-keys": {
"name": "no-dupe-keys",
"value": "error",
"description": "禁止在对象字面量中出现重复的键名",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n bar<span class=\"token punctuation\">:</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span>\n <mark class=\"eslint-error\" data-tip=\"Duplicate key &apos;bar&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-dupe-keys)</span>\">bar</mark><span class=\"token punctuation\">:</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n bar<span class=\"token punctuation\">:</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span>\n baz<span class=\"token punctuation\">:</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-duplicate-case": {
"name": "no-duplicate-case",
"value": "error",
"description": "禁止在 switch 语句中出现重复测试表达式的 case",
"reason": "",
"badExample": "<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">2</span><span class=\"token punctuation\">:</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n <mark class=\"eslint-error\" data-tip=\"Duplicate case label.<br/><span class='eslint-error-rule-id'>eslint(no-duplicate-case)</span>\"><span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">2</span><span class=\"token punctuation\">:</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">3</span><span class=\"token punctuation\">:</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-duplicate-imports": {
"name": "no-duplicate-imports",
"value": "error",
"description": "禁止重复导入模块",
"reason": "",
"badExample": "<span class=\"token keyword\">import</span> <span class=\"token punctuation\">{</span> readFile <span class=\"token punctuation\">}</span> <span class=\"token keyword\">from</span> <span class=\"token string\">'fs'</span><span class=\"token punctuation\">;</span>\n<mark class=\"eslint-error\" data-tip=\"&apos;fs&apos; import is duplicated.<br/><span class='eslint-error-rule-id'>eslint(no-duplicate-imports)</span>\"><span class=\"token keyword\">import</span> <span class=\"token punctuation\">{</span> writeFile <span class=\"token punctuation\">}</span> <span class=\"token keyword\">from</span> <span class=\"token string\">'fs'</span><span class=\"token punctuation\">;</span></mark>",
"goodExample": "<span class=\"token keyword\">import</span> <span class=\"token punctuation\">{</span> readFile<span class=\"token punctuation\">,</span> writeFile <span class=\"token punctuation\">}</span> <span class=\"token keyword\">from</span> <span class=\"token string\">'fs'</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <mark class=\"eslint-error\" data-tip=\"Empty block statement.<br/><span class='eslint-error-rule-id'>eslint(no-empty)</span>\"><span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span></mark>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// do something</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">try</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// do something</span>\n<span class=\"token punctuation\">}</span> <span class=\"token keyword\">catch</span> <span class=\"token punctuation\">(</span>e<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-empty-character-class": {
"name": "no-empty-character-class",
"value": "error",
"description": "禁止在正则表达式中使用空的字符集 []",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> reg <span class=\"token operator\">=</span> <span class=\"token regex\"><mark class=\"eslint-error\" data-tip=\"Empty class.<br/><span class='eslint-error-rule-id'>eslint(no-empty-character-class)</span>\">/abc[]/</mark></span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> reg <span class=\"token operator\">=</span> <span class=\"token regex\">/abc[a-z]/</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">const</span> <mark class=\"eslint-error\" data-tip=\"Unexpected empty object pattern.<br/><span class='eslint-error-rule-id'>eslint(no-empty-pattern)</span>\"><span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span></mark> <span class=\"token operator\">=</span> foo<span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> <span class=\"token punctuation\">{</span> bar <span class=\"token punctuation\">}</span> <span class=\"token operator\">=</span> foo<span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-eq-null": {
"name": "no-eq-null",
"value": "error",
"description": "禁止使用 foo == null，必须使用 foo === null",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Use &apos;===&apos; to compare with null.<br/><span class='eslint-error-rule-id'>eslint(no-eq-null)</span>\">foo <span class=\"token operator\">==</span> <span class=\"token keyword\">null</span></mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">===</span> <span class=\"token keyword\">null</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-eval": {
"name": "no-eval",
"value": "error",
"description": "禁止使用 eval",
"reason": "",
"badExample": "<span class=\"token function\"><mark class=\"eslint-error\" data-tip=\"eval can be harmful.<br/><span class='eslint-error-rule-id'>eslint(no-eval)</span>\">eval</mark></span><span class=\"token punctuation\">(</span><span class=\"token string\">'const foo = 0'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-ex-assign": {
"name": "no-ex-assign",
"value": "error",
"description": "禁止将 catch 的第一个参数 error 重新赋值",
"reason": "",
"badExample": "<span class=\"token keyword\">try</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span> <span class=\"token keyword\">catch</span> <span class=\"token punctuation\">(</span>e<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Do not assign to the exception parameter.<br/><span class='eslint-error-rule-id'>eslint(no-ex-assign)</span>\">e</mark> <span class=\"token operator\">=</span> <span class=\"token number\">10</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">try</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span> <span class=\"token keyword\">catch</span> <span class=\"token punctuation\">(</span>e<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">error</span><span class=\"token punctuation\">(</span>e<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-extend-native": {
"name": "no-extend-native",
"value": "error",
"description": "禁止修改原生对象",
"reason": "修改原生对象可能会与将来版本的 js 冲突",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Array prototype is read only, properties should not be added.<br/><span class='eslint-error-rule-id'>eslint(no-extend-native)</span>\"><span class=\"token class-name\">Array</span><span class=\"token punctuation\">.</span>prototype<span class=\"token punctuation\">.</span><span class=\"token function-variable function\">flat</span> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// do something</span>\n<span class=\"token punctuation\">}</span></mark><span class=\"token punctuation\">;</span>\n\n<span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token punctuation\">[</span><span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">.</span><span class=\"token function\">flat</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">flat</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">arr</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// do something</span>\n<span class=\"token punctuation\">}</span>\n\n<span class=\"token function\">flat</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token punctuation\">[</span><span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-extra-bind": {
"name": "no-extra-bind",
"value": "error",
"description": "禁止出现没必要的 bind",
"reason": "",
"badExample": "<span class=\"token punctuation\">(</span><span class=\"token keyword\">function</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">.</span><span class=\"token function\"><mark class=\"eslint-error\" data-tip=\"The function binding is unnecessary.<br/><span class='eslint-error-rule-id'>eslint(no-extra-bind)</span>\">bind</mark></span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token punctuation\">(</span><span class=\"token keyword\">function</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span><span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">.</span><span class=\"token function\">bind</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": true,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-extra-boolean-cast": {
"name": "no-extra-boolean-cast",
"value": "error",
"description": "禁止不必要的布尔类型转换",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Redundant double negation.<br/><span class='eslint-error-rule-id'>eslint(no-extra-boolean-cast)</span>\"><span class=\"token operator\">!</span><span class=\"token operator\">!</span>foo</mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Redundant Boolean call.<br/><span class='eslint-error-rule-id'>eslint(no-extra-boolean-cast)</span>\"><span class=\"token function\">Boolean</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token operator\">!</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <mark class=\"eslint-error\" data-tip=\"Expected a &apos;break&apos; statement before &apos;case&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-fallthrough)</span>\"><span class=\"token keyword\">case</span> <span class=\"token number\">2</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">doSomethingElse</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">2</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">doSomethingElse</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">switch</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">1</span><span class=\"token punctuation\">:</span>\n <span class=\"token keyword\">case</span> <span class=\"token number\">2</span><span class=\"token punctuation\">:</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-func-assign": {
"name": "no-func-assign",
"value": "error",
"description": "禁止将一个函数声明重新赋值",
"reason": "",
"badExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n<mark class=\"eslint-error\" data-tip=\"&apos;foo&apos; is a function.<br/><span class='eslint-error-rule-id'>eslint(no-func-assign)</span>\">foo</mark> <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">let</span> <span class=\"token function-variable function\">foo</span> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\nfoo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-global-assign": {
"name": "no-global-assign",
"value": "error",
"description": "禁止对全局变量赋值",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Read-only global &apos;Object&apos; should not be modified.<br/><span class='eslint-error-rule-id'>eslint(no-global-assign)</span>\">Object</mark> <span class=\"token operator\">=</span> <span class=\"token keyword\">null</span><span class=\"token punctuation\">;</span>",
"goodExample": "foo <span class=\"token operator\">=</span> <span class=\"token keyword\">null</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-implicit-coercion": {
"name": "no-implicit-coercion",
"value": ["error", { "allow": ["!!"] }],
"description": "禁止使用 ~+ 等难以理解的类型转换，仅允许使用 !!",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> b <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"use `foo.indexOf(&apos;.&apos;) !== -1` instead.<br/><span class='eslint-error-rule-id'>eslint(no-implicit-coercion)</span>\"><span class=\"token operator\">~</span>foo<span class=\"token punctuation\">.</span><span class=\"token function\">indexOf</span><span class=\"token punctuation\">(</span><span class=\"token string\">'.'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> n <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"use `Number(foo)` instead.<br/><span class='eslint-error-rule-id'>eslint(no-implicit-coercion)</span>\"><span class=\"token operator\">+</span>foo</mark><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> m <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"use `Number(foo)` instead.<br/><span class='eslint-error-rule-id'>eslint(no-implicit-coercion)</span>\"><span class=\"token number\">1</span> <span class=\"token operator\">*</span> foo</mark><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> s <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"use `String(foo)` instead.<br/><span class='eslint-error-rule-id'>eslint(no-implicit-coercion)</span>\"><span class=\"token string\">''</span> <span class=\"token operator\">+</span> foo</mark><span class=\"token punctuation\">;</span>\n<mark class=\"eslint-error\" data-tip=\"use `foo = String(foo)` instead.<br/><span class='eslint-error-rule-id'>eslint(no-implicit-coercion)</span>\">foo <span class=\"token operator\">+=</span> <span class=\"token string\">''</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> b <span class=\"token operator\">=</span> foo<span class=\"token punctuation\">.</span><span class=\"token function\">indexOf</span><span class=\"token punctuation\">(</span><span class=\"token string\">'.'</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">!==</span> <span class=\"token operator\">-</span><span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> n <span class=\"token operator\">=</span> <span class=\"token function\">Number</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> m <span class=\"token operator\">=</span> <span class=\"token function\">Number</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> s <span class=\"token operator\">=</span> <span class=\"token function\">String</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nfoo <span class=\"token operator\">=</span> <span class=\"token function\">String</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">const</span> c <span class=\"token operator\">=</span> <span class=\"token operator\">!</span><span class=\"token operator\">!</span>foo<span class=\"token punctuation\">;</span>",
"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": "<mark class=\"eslint-error\" data-tip=\"Implied eval. Consider passing a function instead of a string.<br/><span class='eslint-error-rule-id'>eslint(no-implied-eval)</span>\"><span class=\"token function\">setTimeout</span><span class=\"token punctuation\">(</span><span class=\"token string\">'alert(\"Hello World\");'</span><span class=\"token punctuation\">,</span> <span class=\"token number\">1000</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token function\">setTimeout</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">alert</span><span class=\"token punctuation\">(</span><span class=\"token string\">'Hello World'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span> <span class=\"token number\">1000</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-import-assign": {
"name": "no-import-assign",
"value": "error",
"description": "禁止对导入的模块进行赋值",
"reason": "",
"badExample": "<span class=\"token keyword\">import</span> foo <span class=\"token keyword\">from</span> <span class=\"token string\">'foo'</span><span class=\"token punctuation\">;</span>\n<mark class=\"eslint-error\" data-tip=\"&apos;foo&apos; is read-only.<br/><span class='eslint-error-rule-id'>eslint(no-import-assign)</span>\">foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span></mark><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">import</span> <span class=\"token operator\">*</span> <span class=\"token keyword\">as</span> bar <span class=\"token keyword\">from</span> <span class=\"token string\">'bar'</span><span class=\"token punctuation\">;</span>\n<mark class=\"eslint-error\" data-tip=\"The members of &apos;bar&apos; are read-only.<br/><span class='eslint-error-rule-id'>eslint(no-import-assign)</span>\">bar<span class=\"token punctuation\">.</span>baz <span class=\"token operator\">=</span> <span class=\"token number\">1</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">import</span> foo <span class=\"token keyword\">from</span> <span class=\"token string\">'foo'</span><span class=\"token punctuation\">;</span>\nfoo<span class=\"token punctuation\">.</span>baz <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">import</span> <span class=\"token operator\">*</span> <span class=\"token keyword\">as</span> bar <span class=\"token keyword\">from</span> <span class=\"token string\">'bar'</span><span class=\"token punctuation\">;</span>\nbar<span class=\"token punctuation\">.</span>baz<span class=\"token punctuation\">.</span>qux <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Move function declaration to program root.<br/><span class='eslint-error-rule-id'>eslint(no-inner-declarations)</span>\"><span class=\"token keyword\">function</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">const</span> <span class=\"token function-variable function\">bar</span> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-invalid-regexp": {
"name": "no-invalid-regexp",
"value": "error",
"description": "禁止在 RegExp 构造函数中出现非法的正则表达式",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> reg1 <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Invalid regular expression: /[/: Unterminated character class.<br/><span class='eslint-error-rule-id'>eslint(no-invalid-regexp)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span><span class=\"token string\">'['</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> reg2 <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Invalid flags supplied to RegExp constructor &apos;z&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-invalid-regexp)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span><span class=\"token string\">'.'</span><span class=\"token punctuation\">,</span> <span class=\"token string\">'z'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> reg1 <span class=\"token operator\">=</span> <span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span><span class=\"token string\">'[a-z]'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> reg2 <span class=\"token operator\">=</span> <span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span><span class=\"token string\">'.'</span><span class=\"token punctuation\">,</span> <span class=\"token string\">'g'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-invalid-this": {
"name": "no-invalid-this",
"value": "error",
"description": "禁止在类之外的地方使用 this",
"reason": "只允许在 class 中使用 this",
"badExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\"><mark class=\"eslint-error\" data-tip=\"Unexpected &apos;this&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-invalid-this)</span>\">this</mark></span><span class=\"token punctuation\">.</span>a <span class=\"token operator\">=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>a <span class=\"token operator\">=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><mark class=\"eslint-error\" data-tip=\"Irregular whitespace not allowed.<br/><span class='eslint-error-rule-id'>eslint(no-irregular-whitespace)</span>\"> </mark><span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token string\">' '</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token regex\">/ /</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> baz <span class=\"token operator\">=</span> <span class=\"token template-string\"><span class=\"token string\">` `</span></span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-iterator": {
"name": "no-iterator",
"value": "error",
"description": "禁止使用 __iterator__",
"reason": "__iterator__ 是一个已废弃的属性\n使用 [Symbol.iterator] 替代它",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Reserved name &apos;__iterator__&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-iterator)</span>\"><span class=\"token class-name\">Foo</span><span class=\"token punctuation\">.</span>prototype<span class=\"token punctuation\">.</span><span class=\"token function-variable function\">__iterator__</span></mark> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token keyword\">new</span> <span class=\"token class-name\">FooIterator</span><span class=\"token punctuation\">(</span><span class=\"token keyword\">this</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">let</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\nfoo<span class=\"token punctuation\">[</span>Symbol<span class=\"token punctuation\">.</span>iterator<span class=\"token punctuation\">]</span> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span><span class=\"token operator\">*</span> <span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">yield</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">yield</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">yield</span> <span class=\"token number\">3</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\nconsole<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">[</span><span class=\"token operator\">...</span>foo<span class=\"token punctuation\">]</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token comment\">// [1, 2, 3]</span>",
"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": "<mark class=\"eslint-error\" data-tip=\"Unexpected labeled statement.<br/><span class='eslint-error-rule-id'>eslint(no-labels)</span>\">loop<span class=\"token punctuation\">:</span>\n <span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span><span class=\"token keyword\">let</span> i <span class=\"token operator\">=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">;</span> i <span class=\"token operator\"><</span> <span class=\"token number\">5</span><span class=\"token punctuation\">;</span> i<span class=\"token operator\">++</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Unexpected label in continue statement.<br/><span class='eslint-error-rule-id'>eslint(no-labels)</span>\"><span class=\"token keyword\">continue</span> loop<span class=\"token punctuation\">;</span></mark>\n <span class=\"token punctuation\">}</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span></mark>\n<span class=\"token comment\">// 0 2 3 4</span>",
"goodExample": "<span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span><span class=\"token keyword\">let</span> i <span class=\"token operator\">=</span> <span class=\"token number\">0</span><span class=\"token punctuation\">;</span> i <span class=\"token operator\"><</span> <span class=\"token number\">5</span><span class=\"token punctuation\">;</span> i<span class=\"token operator\">++</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>i <span class=\"token operator\">===</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">continue</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>i<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token comment\">// 0 2 3 4</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-lone-blocks": {
"name": "no-lone-blocks",
"value": "error",
"description": "禁止使用没必要的 {} 作为代码块",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Block is redundant.<br/><span class='eslint-error-rule-id'>eslint(no-lone-blocks)</span>\"><span class=\"token punctuation\">{</span>\n <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span></mark>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token number\"><mark class=\"eslint-error\" data-tip=\"This number literal will lose precision at runtime.<br/><span class='eslint-error-rule-id'>eslint(no-loss-of-precision)</span>\">5123000000000000000000000000001</mark></span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">12345</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token regex\"><mark class=\"eslint-error\" data-tip=\"Unexpected combined character in character class.<br/><span class='eslint-error-rule-id'>eslint(no-misleading-character-class)</span>\">/^[Á]$/u</mark></span><span class=\"token punctuation\">.</span><span class=\"token function\">test</span><span class=\"token punctuation\">(</span><span class=\"token string\">'Á'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// false</span>",
"goodExample": "<span class=\"token regex\">/^[A]$/u</span><span class=\"token punctuation\">.</span><span class=\"token function\">test</span><span class=\"token punctuation\">(</span><span class=\"token string\">'A'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// true</span>",
"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": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token string\"><mark class=\"eslint-error\" data-tip=\"Multiline support is limited to browsers supporting ES5 only.<br/><span class='eslint-error-rule-id'>eslint(no-multi-str)</span>\">'Line 1\\\nLine 2'</mark></span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token template-string\"><span class=\"token string\">`Line 1\nLine 2`</span></span><span class=\"token punctuation\">;</span>",
"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": "error",
"description": "禁止直接 new 一个类而不赋值",
"reason": "new 应该作为创建一个类的实例的方法，所以不能不赋值",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Do not use &apos;new&apos; for side effects.<br/><span class='eslint-error-rule-id'>eslint(no-new)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">Foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span></mark>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token keyword\">new</span> <span class=\"token class-name\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-new-func": {
"name": "no-new-func",
"value": "error",
"description": "禁止使用 new Function",
"reason": "这和 eval 是等价的",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"The Function constructor is eval.<br/><span class='eslint-error-rule-id'>eslint(no-new-func)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">Function</span><span class=\"token punctuation\">(</span><span class=\"token string\">'a'</span><span class=\"token punctuation\">,</span> <span class=\"token string\">'b'</span><span class=\"token punctuation\">,</span> <span class=\"token string\">'return a + b'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> <span class=\"token function-variable function\">foo</span> <span class=\"token operator\">=</span> <span class=\"token keyword\">function</span> <span class=\"token punctuation\">(</span><span class=\"token parameter\">a<span class=\"token punctuation\">,</span> b</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> a <span class=\"token operator\">+</span> b<span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-new-object": {
"name": "no-new-object",
"value": "error",
"description": "禁止直接 new Object",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"The object literal notation {} is preferrable.<br/><span class='eslint-error-rule-id'>eslint(no-new-object)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">Object</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-new-symbol": {
"name": "no-new-symbol",
"value": "error",
"description": "禁止使用 new 来生成 Symbol",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token keyword\">new</span> <span class=\"token class-name\"><mark class=\"eslint-error\" data-tip=\"`Symbol` cannot be called as a constructor.<br/><span class='eslint-error-rule-id'>eslint(no-new-symbol)</span>\">Symbol</mark></span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token function\">Symbol</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-new-wrappers": {
"name": "no-new-wrappers",
"value": "error",
"description": "禁止使用 new 来生成 String, Number 或 Boolean",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> s <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Do not use String as a constructor.<br/><span class='eslint-error-rule-id'>eslint(no-new-wrappers)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">String</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> n <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Do not use Number as a constructor.<br/><span class='eslint-error-rule-id'>eslint(no-new-wrappers)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">Number</span><span class=\"token punctuation\">(</span><span class=\"token number\">1</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> b <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Do not use Boolean as a constructor.<br/><span class='eslint-error-rule-id'>eslint(no-new-wrappers)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">Boolean</span><span class=\"token punctuation\">(</span><span class=\"token boolean\">true</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> s <span class=\"token operator\">=</span> <span class=\"token function\">String</span><span class=\"token punctuation\">(</span>someValue<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> n <span class=\"token operator\">=</span> <span class=\"token function\">Number</span><span class=\"token punctuation\">(</span>someValue<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> b <span class=\"token operator\">=</span> <span class=\"token function\">Boolean</span><span class=\"token punctuation\">(</span>someValue<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-obj-calls": {
"name": "no-obj-calls",
"value": "error",
"description": "禁止将 Math, JSON 或 Reflect 直接作为函数调用",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"&apos;Math&apos; is not a function.<br/><span class='eslint-error-rule-id'>eslint(no-obj-calls)</span>\"><span class=\"token function\">Math</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"&apos;JSON&apos; is not a function.<br/><span class='eslint-error-rule-id'>eslint(no-obj-calls)</span>\"><span class=\"token constant\">JSON</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> baz <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"&apos;Reflect&apos; is not a function.<br/><span class='eslint-error-rule-id'>eslint(no-obj-calls)</span>\"><span class=\"token function\">Reflect</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> Math<span class=\"token punctuation\">.</span><span class=\"token function\">random</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token constant\">JSON</span><span class=\"token punctuation\">.</span><span class=\"token function\">parse</span><span class=\"token punctuation\">(</span><span class=\"token string\">'{}'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> baz <span class=\"token operator\">=</span> Reflect<span class=\"token punctuation\">.</span><span class=\"token function\">get</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">{</span> x<span class=\"token punctuation\">:</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span> y<span class=\"token punctuation\">:</span> <span class=\"token number\">2</span> <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span> <span class=\"token string\">'x'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">bar</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Assignment to function parameter &apos;bar&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-param-reassign)</span>\">bar</mark> <span class=\"token operator\">=</span> bar <span class=\"token operator\">||</span> <span class=\"token string\">''</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">bar_</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n bar <span class=\"token operator\">=</span> bar_ <span class=\"token operator\">||</span> <span class=\"token string\">''</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">new</span> <span class=\"token class-name\">Promise</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">resolve<span class=\"token punctuation\">,</span> reject</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>someCondition<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Return values from promise executor functions cannot be read.<br/><span class='eslint-error-rule-id'>eslint(no-promise-executor-return)</span>\"><span class=\"token keyword\">return</span> defaultResult<span class=\"token punctuation\">;</span></mark>\n <span class=\"token punctuation\">}</span>\n <span class=\"token function\">getSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">err<span class=\"token punctuation\">,</span> result</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>err<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">reject</span><span class=\"token punctuation\">(</span>err<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span> <span class=\"token keyword\">else</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">resolve</span><span class=\"token punctuation\">(</span>result<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">new</span> <span class=\"token class-name\">Promise</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">resolve<span class=\"token punctuation\">,</span> reject</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>someCondition<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">resolve</span><span class=\"token punctuation\">(</span>defaultResult<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">return</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token function\">getSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">err<span class=\"token punctuation\">,</span> result</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>err<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">reject</span><span class=\"token punctuation\">(</span>err<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span> <span class=\"token keyword\">else</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">resolve</span><span class=\"token punctuation\">(</span>result<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-proto": {
"name": "no-proto",
"value": "error",
"description": "禁止使用 __proto__",
"reason": "__proto__ 是已废弃的语法",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"The &apos;__proto__&apos; property is deprecated.<br/><span class='eslint-error-rule-id'>eslint(no-proto)</span>\">bar<span class=\"token punctuation\">.</span>__proto__</mark><span class=\"token punctuation\">;</span>\n<mark class=\"eslint-error\" data-tip=\"The &apos;__proto__&apos; property is deprecated.<br/><span class='eslint-error-rule-id'>eslint(no-proto)</span>\">bar<span class=\"token punctuation\">.</span>__proto__</mark> <span class=\"token operator\">=</span> baz<span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> Object<span class=\"token punctuation\">.</span><span class=\"token function\">getPrototypeOf</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nObject<span class=\"token punctuation\">.</span><span class=\"token function\">setPrototypeOf</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">,</span> baz<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">const</span> reg1 <span class=\"token operator\">=</span> <span class=\"token regex\"><mark class=\"eslint-error\" data-tip=\"Spaces are hard to count. Use {3}.<br/><span class='eslint-error-rule-id'>eslint(no-regex-spaces)</span>\">/foo bar/</mark></span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> reg2 <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Spaces are hard to count. Use {3}.<br/><span class='eslint-error-rule-id'>eslint(no-regex-spaces)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo bar'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> reg1 <span class=\"token operator\">=</span> <span class=\"token regex\">/foo {3}bar/</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> reg2 <span class=\"token operator\">=</span> <span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo {3}bar'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Return statement should not contain assignment.<br/><span class='eslint-error-rule-id'>eslint(no-return-assign)</span>\"><span class=\"token keyword\">return</span> <span class=\"token punctuation\">(</span>bar <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n bar <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">return</span> bar<span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"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 <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"&apos;foo&apos; is assigned to itself.<br/><span class='eslint-error-rule-id'>eslint(no-self-assign)</span>\">foo</mark><span class=\"token punctuation\">;</span>",
"goodExample": "foo <span class=\"token operator\">=</span> bar<span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-self-compare": {
"name": "no-self-compare",
"value": "error",
"description": "禁止将自己与自己比较",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Comparing to itself is potentially pointless.<br/><span class='eslint-error-rule-id'>eslint(no-self-compare)</span>\">foo <span class=\"token operator\">===</span> foo</mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Comparing to itself is potentially pointless.<br/><span class='eslint-error-rule-id'>eslint(no-self-compare)</span>\"><span class=\"token number\">NaN</span> <span class=\"token operator\">===</span> <span class=\"token number\">NaN</span></mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">===</span> bar<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token function\">isNaN</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-sequences": {
"name": "no-sequences",
"value": "error",
"description": "禁止使用逗号操作符",
"reason": "",
"badExample": "foo <span class=\"token operator\">=</span> <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\"><mark class=\"eslint-error\" data-tip=\"Unexpected use of comma operator.<br/><span class='eslint-error-rule-id'>eslint(no-sequences)</span>\">,</mark></span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nfoo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-setter-return": {
"name": "no-setter-return",
"value": "error",
"description": "禁止 setter 有返回值",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">set</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">value</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue <span class=\"token operator\">=</span> <span class=\"token string\">'bar '</span> <span class=\"token operator\">+</span> value<span class=\"token punctuation\">;</span>\n <mark class=\"eslint-error\" data-tip=\"Setter cannot return a value.<br/><span class='eslint-error-rule-id'>eslint(no-setter-return)</span>\"><span class=\"token keyword\">return</span> <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue<span class=\"token punctuation\">;</span></mark>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">set</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">value</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>barValue <span class=\"token operator\">=</span> <span class=\"token string\">'bar '</span> <span class=\"token operator\">+</span> value<span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">const</span> <span class=\"token keyword\"><mark class=\"eslint-error\" data-tip=\"Shadowing of global property &apos;undefined&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-shadow-restricted-names)</span>\">undefined</mark></span> <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token parameter\"><span class=\"token number\"><mark class=\"eslint-error\" data-tip=\"Shadowing of global property &apos;NaN&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-shadow-restricted-names)</span>\">NaN</mark></span></span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">function</span> <span class=\"token function\"><mark class=\"eslint-error\" data-tip=\"Shadowing of global property &apos;Infinity&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-shadow-restricted-names)</span>\">Infinity</mark></span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>",
"goodExample": "console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span><span class=\"token keyword\">undefined</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nconsole<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span><span class=\"token number\">NaN</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nconsole<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span><span class=\"token number\">Infinity</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-sparse-arrays": {
"name": "no-sparse-arrays",
"value": "error",
"description": "禁止在数组中出现连续的逗号",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Unexpected comma in middle of array.<br/><span class='eslint-error-rule-id'>eslint(no-sparse-arrays)</span>\"><span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-template-curly-in-string": {
"name": "no-template-curly-in-string",
"value": "error",
"description": "禁止在普通字符串中出现模版字符串里的变量形式",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token string\"><mark class=\"eslint-error\" data-tip=\"Unexpected template string expression.<br/><span class='eslint-error-rule-id'>eslint(no-template-curly-in-string)</span>\">'Hello ${bar}'</mark></span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token string\">'Hello {bar}'</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token keyword\">extends</span> <span class=\"token class-name\">Bar</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\"><mark class=\"eslint-error\" data-tip=\"&apos;this&apos; is not allowed before &apos;super()&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-this-before-super)</span>\">this</mark></span><span class=\"token punctuation\">.</span>foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">super</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token keyword\">extends</span> <span class=\"token class-name\">Bar</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">super</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">this</span><span class=\"token punctuation\">.</span>foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-throw-literal": {
"name": "no-throw-literal",
"value": "error",
"description": "禁止 throw 字面量，必须 throw 一个 Error 对象",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Expected an error object to be thrown.<br/><span class='eslint-error-rule-id'>eslint(no-throw-literal)</span>\"><span class=\"token keyword\">throw</span> <span class=\"token string\">'foo'</span><span class=\"token punctuation\">;</span></mark>\n<mark class=\"eslint-error\" data-tip=\"Expected an error object to be thrown.<br/><span class='eslint-error-rule-id'>eslint(no-throw-literal)</span>\"><span class=\"token keyword\">throw</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span></mark>",
"goodExample": "<span class=\"token keyword\">throw</span> <span class=\"token keyword\">new</span> <span class=\"token class-name\">Error</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-undef": {
"name": "no-undef",
"value": "error",
"description": "禁止使用未定义的变量",
"reason": "",
"badExample": "<span class=\"token function\"><mark class=\"eslint-error\" data-tip=\"&apos;foo&apos; is not defined.<br/><span class='eslint-error-rule-id'>esli<mark class=\"eslint-error\" data-tip=\"&apos;bar&apos; is not defined.<br/><span class='eslint-error-rule-id'>eslint(no-undef)</span>\">nt(</mark>no-undef)</span>\">foo</mark></span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<span class=\"token function\">foo</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token keyword\">typeof</span> baz <span class=\"token operator\">===</span> <span class=\"token string\">'number'</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-undef-init": {
"name": "no-undef-init",
"value": "error",
"description": "禁止将 undefined 赋值给变量",
"reason": "",
"badExample": "<span class=\"token keyword\">let</span> <mark class=\"eslint-error\" data-tip=\"It&apos;s not necessary to initialize &apos;foo&apos; to undefined.<br/><span class='eslint-error-rule-id'>eslint(no-undef-init)</span>\">foo <span class=\"token operator\">=</span> <span class=\"token keyword\">undefined</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">let</span> foo<span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">let</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">10</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">while</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"&apos;foo&apos; is not modified in this loop.<br/><span class='eslint-error-rule-id'>eslint(no-unmodified-loop-condition)</span>\">foo</mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">let</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">10</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">while</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n foo<span class=\"token operator\">--</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span><span class=\"token punctuation\">;</span>\n <mark class=\"eslint-error\" data-tip=\"Unreachable code.<br/><span class='eslint-error-rule-id'>eslint(no-unreachable)</span>\"><span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span><span class=\"token punctuation\">;</span>\n <span class=\"token comment\">// const bar = 1;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-unreachable-loop": {
"name": "no-unreachable-loop",
"value": "error",
"description": "禁止在第一轮循环时就一定会退出循环的情况出现",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Invalid loop. Its body allows only one iteration.<br/><span class='eslint-error-rule-id'>eslint(no-unreachable-loop)</span>\"><span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span>foo <span class=\"token keyword\">of</span> bar<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">.</span>id <span class=\"token operator\">===</span> id<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span></mark>",
"goodExample": "<span class=\"token keyword\">for</span> <span class=\"token punctuation\">(</span>foo <span class=\"token keyword\">of</span> bar<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">.</span>id <span class=\"token operator\">===</span> id<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">break</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-unsafe-finally": {
"name": "no-unsafe-finally",
"value": "error",
"description": "禁止在 finally 中出现 return, throw, break 或 continue",
"reason": "finally 中的语句会在 try 之前执行",
"badExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">try</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span> <span class=\"token keyword\">finally</span> <span class=\"token punctuation\">{</span>\n <span class=\"token comment\">// finally 会在 try 之前执行，故会 return 2</span>\n <mark class=\"eslint-error\" data-tip=\"Unsafe usage of ReturnStatement.<br/><span class='eslint-error-rule-id'>eslint(no-unsafe-finally)</span>\"><span class=\"token keyword\">return</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span></mark>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">try</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span> <span class=\"token keyword\">finally</span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span><span class=\"token number\">2</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-unsafe-negation": {
"name": "no-unsafe-negation",
"value": "error",
"description": "禁止在 in 或 instanceof 操作符的左侧变量前使用感叹号",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Unexpected negating the left operand of &apos;in&apos; operator.<br/><span class='eslint-error-rule-id'>eslint(no-unsafe-negation)</span>\"><span class=\"token operator\">!</span>key</mark> <span class=\"token keyword\">in</span> object<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Unexpected negating the left operand of &apos;instanceof&apos; operator.<br/><span class='eslint-error-rule-id'>eslint(no-unsafe-negation)</span>\"><span class=\"token operator\">!</span>obj</mark> <span class=\"token keyword\">instanceof</span> <span class=\"token class-name\">SomeClass</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token operator\">!</span><span class=\"token punctuation\">(</span>key <span class=\"token keyword\">in</span> object<span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token operator\">!</span><span class=\"token punctuation\">(</span>obj <span class=\"token keyword\">instanceof</span> <span class=\"token class-name\">SomeClass</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-unused-expressions": {
"name": "no-unused-expressions",
"value": ["error", { "allowShortCircuit": true, "allowTernary": true, "allowTaggedTemplates": true }],
"description": "禁止无用的表达式",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Expected an assignment or function call and instead saw an expression.<br/><span class='eslint-error-rule-id'>eslint(no-unused-expressions)</span>\"><span class=\"token number\">1</span><span class=\"token punctuation\">;</span></mark>\n<mark class=\"eslint-error\" data-tip=\"Expected an assignment or function call and instead saw an expression.<br/><span class='eslint-error-rule-id'>eslint(no-unused-expressions)</span>\">foo<span class=\"token punctuation\">;</span></mark>\n<mark class=\"eslint-error\" data-tip=\"Expected an assignment or function call and instead saw an expression.<br/><span class='eslint-error-rule-id'>eslint(no-unused-expressions)</span>\"><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span></mark>\n<mark class=\"eslint-error\" data-tip=\"Expected an assignment or function call and instead saw an expression.<br/><span class='eslint-error-rule-id'>eslint(no-unused-expressions)</span>\">foo <span class=\"token operator\">&&</span> bar<span class=\"token punctuation\">;</span></mark>\n<mark class=\"eslint-error\" data-tip=\"Expected an assignment or function call and instead saw an expression.<br/><span class='eslint-error-rule-id'>eslint(no-unused-expressions)</span>\">foo <span class=\"token operator\">||</span> bar<span class=\"token punctuation\">;</span></mark>\n<mark class=\"eslint-error\" data-tip=\"Expected an assignment or function call and instead saw an expression.<br/><span class='eslint-error-rule-id'>eslint(no-unused-expressions)</span>\">foo <span class=\"token operator\">?</span> bar <span class=\"token punctuation\">:</span> baz<span class=\"token punctuation\">;</span></mark>\n<mark class=\"eslint-error\" data-tip=\"Expected an assignment or function call and instead saw an expression.<br/><span class='eslint-error-rule-id'>eslint(no-unused-expressions)</span>\"><span class=\"token template-string\"><span class=\"token string\">`bar`</span></span><span class=\"token punctuation\">;</span></mark>",
"goodExample": "<span class=\"token string\">'use strict'</span><span class=\"token punctuation\">;</span>\nfoo <span class=\"token operator\">&&</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nfoo <span class=\"token operator\">||</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nfoo <span class=\"token operator\">?</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">:</span> <span class=\"token function\">baz</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nfoo<span class=\"token template-string\"><span class=\"token string\">`bar`</span></span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">let</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<mark class=\"eslint-error\" data-tip=\"&apos;foo&apos; is assigned a value but never used.<br/><span class='eslint-error-rule-id'>eslint(no-unused-vars)</span>\">foo</mark> <span class=\"token operator\">=</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">function</span> <span class=\"token function\"><mark class=\"eslint-error\" data-tip=\"&apos;bar&apos; is defined but never used.<br/><span class='eslint-error-rule-id'>eslint(no-unused-vars)</span>\">bar</mark></span><span class=\"token punctuation\">(</span><span class=\"token parameter\">baz</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n\n<span class=\"token keyword\">const</span> <span class=\"token punctuation\">{</span> <mark class=\"eslint-error\" data-tip=\"&apos;baz&apos; is assigned a value but never used.<br/><span class='eslint-error-rule-id'>eslint(n<mark class=\"eslint-error\" data-tip=\"&apos;rest&apos; is assigned a value but never used.<br/><span class='eslint-error-rule-id'>eslint(no-unused-vars)</span>\">o-un</mark>used-vars)</span>\">baz</mark><span class=\"token punctuation\">,</span> <span class=\"token operator\">...</span>rest <span class=\"token punctuation\">}</span> <span class=\"token operator\">=</span> data<span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">let</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\nconsole<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">function</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">baz</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n<span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">const</span> <span class=\"token punctuation\">{</span> baz<span class=\"token punctuation\">,</span> <span class=\"token operator\">...</span>rest <span class=\"token punctuation\">}</span> <span class=\"token operator\">=</span> data<span class=\"token punctuation\">;</span>\nconsole<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>baz<span class=\"token punctuation\">,</span> rest<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">try</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span> <span class=\"token keyword\">catch</span> <span class=\"token punctuation\">(</span>e<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>",
"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<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"&apos;foo&apos; was used before it was defined.<br/><span class='eslint-error-rule-id'>eslint(no-use-before-define)</span>\">foo</mark><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">new</span> <span class=\"token class-name\"><mark class=\"eslint-error\" data-tip=\"&apos;Baz&apos; was used before it was defined.<br/><span class='eslint-error-rule-id'>eslint(no-use-before-define)</span>\">Baz</mark></span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">class</span> <span class=\"token class-name\">Baz</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n console<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\nconsole<span class=\"token punctuation\">.</span><span class=\"token function\">log</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">function</span> <span class=\"token function\">bar</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n\n<span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">new</span> <span class=\"token class-name\">Baz</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">class</span> <span class=\"token class-name\">Baz</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">Baz</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-useless-backreference": {
"name": "no-useless-backreference",
"value": "error",
"description": "禁止正则表达式中出现无用的回溯引用",
"reason": "某些回溯引用语法上没问题，但是会永远匹配到空字符串",
"badExample": "<span class=\"token regex\"><mark class=\"eslint-error\" data-tip=\"Backreference &apos;\\1&apos; will be ignored. It references group &apos;(a)&apos; which is in another alternative.<br/><span class='eslint-error-rule-id'>eslint(no-useless-backreference)</span>\">/^(?:(a)|\\1b)$/</mark></span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// reference to (a) into another alternative</span>",
"goodExample": "<span class=\"token regex\">/^(?:(a)|(b)\\2)$/</span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// reference to (b)</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-useless-call": {
"name": "no-useless-call",
"value": "error",
"description": "禁止出现没必要的 call 或 apply",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Unnecessary &apos;.call()&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-useless-call)</span>\"><span class=\"token function\">foo</span><span class=\"token punctuation\">.</span><span class=\"token function\">call</span><span class=\"token punctuation\">(</span><span class=\"token keyword\">null</span><span class=\"token punctuation\">,</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span> <span class=\"token comment\">// foo(1, 2, 3)</span>\n<mark class=\"eslint-error\" data-tip=\"Unnecessary &apos;.apply()&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-useless-call)</span>\"><span class=\"token function\">foo</span><span class=\"token punctuation\">.</span><span class=\"token function\">apply</span><span class=\"token punctuation\">(</span><span class=\"token keyword\">null</span><span class=\"token punctuation\">,</span> <span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span> <span class=\"token comment\">// foo(1, 2, 3)</span>\n\n<mark class=\"eslint-error\" data-tip=\"Unnecessary &apos;.call()&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-useless-call)</span>\">foo<span class=\"token punctuation\">.</span><span class=\"token function\">bar</span><span class=\"token punctuation\">.</span><span class=\"token function\">call</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">,</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span> <span class=\"token comment\">// foo.bar(1, 2, 3);</span>\n<mark class=\"eslint-error\" data-tip=\"Unnecessary &apos;.apply()&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-useless-call)</span>\">foo<span class=\"token punctuation\">.</span><span class=\"token function\">bar</span><span class=\"token punctuation\">.</span><span class=\"token function\">apply</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">,</span> <span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span> <span class=\"token comment\">// foo.bar(1, 2, 3);</span>",
"goodExample": "<span class=\"token function\">foo</span><span class=\"token punctuation\">.</span><span class=\"token function\">call</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">,</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token function\">foo</span><span class=\"token punctuation\">.</span><span class=\"token function\">apply</span><span class=\"token punctuation\">(</span>bar<span class=\"token punctuation\">,</span> <span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\nfoo<span class=\"token punctuation\">.</span><span class=\"token function\">bar</span><span class=\"token punctuation\">.</span><span class=\"token function\">call</span><span class=\"token punctuation\">(</span>baz<span class=\"token punctuation\">,</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\nfoo<span class=\"token punctuation\">.</span><span class=\"token function\">bar</span><span class=\"token punctuation\">.</span><span class=\"token function\">apply</span><span class=\"token punctuation\">(</span>baz<span class=\"token punctuation\">,</span> <span class=\"token punctuation\">[</span><span class=\"token number\">1</span><span class=\"token punctuation\">,</span> <span class=\"token number\">2</span><span class=\"token punctuation\">,</span> <span class=\"token number\">3</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-useless-catch": {
"name": "no-useless-catch",
"value": "error",
"description": "禁止在 catch 中仅仅只是把错误 throw 出去",
"reason": "这样的 catch 是没有意义的，等价于直接执行 try 里的代码",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Unnecessary try/catch wrapper.<br/><span class='eslint-error-rule-id'>eslint(no-useless-catch)</span>\"><span class=\"token keyword\">try</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">doSomethingThatMightThrow</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span> <span class=\"token keyword\">catch</span> <span class=\"token punctuation\">(</span>e<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">throw</span> e<span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span></mark>",
"goodExample": "<span class=\"token function\">doSomethingThatMightThrow</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">try</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">doSomethingThatMightThrow</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span> <span class=\"token keyword\">catch</span> <span class=\"token punctuation\">(</span>e<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">doSomethingBeforeRethrow</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">throw</span> e<span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-useless-computed-key": {
"name": "no-useless-computed-key",
"value": "error",
"description": "禁止出现没必要的计算键名",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Unnecessarily computed property [&apos;1&apos;] found.<br/><span class='eslint-error-rule-id'>eslint(no-useless-computed-key)</span>\"><span class=\"token punctuation\">[</span><span class=\"token string\">'1'</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">:</span> <span class=\"token number\">1</span></mark><span class=\"token punctuation\">,</span>\n <mark class=\"eslint-error\" data-tip=\"Unnecessarily computed property [&apos;bar&apos;] found.<br/><span class='eslint-error-rule-id'>eslint(no-useless-computed-key)</span>\"><span class=\"token punctuation\">[</span><span class=\"token string\">'bar'</span><span class=\"token punctuation\">]</span><span class=\"token punctuation\">:</span> <span class=\"token string\">'bar'</span></mark><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span>\n <span class=\"token number\">1</span><span class=\"token punctuation\">:</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span>\n bar<span class=\"token punctuation\">:</span> <span class=\"token string\">'bar'</span><span class=\"token punctuation\">,</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>",
"fixable": true,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-useless-concat": {
"name": "no-useless-concat",
"value": "error",
"description": "禁止出现没必要的字符串连接",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token string\">'f'</span> <span class=\"token operator\"><mark class=\"eslint-error\" data-tip=\"Unexpected string concatenation of literals.<br/><span class='eslint-error-rule-id'>eslint(no-useless-concat)</span>\">+</mark></span> <span class=\"token string\">'oo'</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token template-string\"><span class=\"token string\">`b`</span></span> <span class=\"token operator\"><mark class=\"eslint-error\" data-tip=\"Unexpected string concatenation of literals.<br/><span class='eslint-error-rule-id'>eslint(no-useless-concat)</span>\">+</mark></span> <span class=\"token template-string\"><span class=\"token string\">`ar`</span></span><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token string\">'fo'</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token number\">1</span> <span class=\"token operator\">+</span> <span class=\"token template-string\"><span class=\"token string\">`ar`</span></span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-useless-constructor": {
"name": "no-useless-constructor",
"value": "error",
"description": "禁止出现没必要的 constructor",
"reason": "",
"badExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Useless constructor.<br/><span class='eslint-error-rule-id'>eslint(no-useless-constructor)</span>\"><span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span></mark>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">class</span> <span class=\"token class-name\">Bar</span> <span class=\"token keyword\">extends</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Useless constructor.<br/><span class='eslint-error-rule-id'>eslint(no-useless-constructor)</span>\"><span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token parameter\"><span class=\"token operator\">...</span>args</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">super</span><span class=\"token punctuation\">(</span><span class=\"token operator\">...</span>args<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">class</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">class</span> <span class=\"token class-name\">Bar</span> <span class=\"token keyword\">extends</span> <span class=\"token class-name\">Foo</span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">constructor</span><span class=\"token punctuation\">(</span><span class=\"token parameter\"><span class=\"token operator\">...</span>args</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">super</span><span class=\"token punctuation\">(</span><span class=\"token operator\">...</span>args<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token function\">doSomething</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n <span class=\"token punctuation\">}</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">import</span> <span class=\"token punctuation\">{</span> <mark class=\"eslint-error\" data-tip=\"Import foo unnecessarily renamed.<br/><span class='eslint-error-rule-id'>eslint(no-useless-rename)</span>\">foo <span class=\"token keyword\">as</span> foo</mark> <span class=\"token punctuation\">}</span> <span class=\"token keyword\">from</span> <span class=\"token string\">'foo'</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">export</span> <span class=\"token punctuation\">{</span> <mark class=\"eslint-error\" data-tip=\"Export bar unnecessarily renamed.<br/><span class='eslint-error-rule-id'>eslint(no-useless-rename)</span>\">bar <span class=\"token keyword\">as</span> bar</mark> <span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">let</span> <span class=\"token punctuation\">{</span> <mark class=\"eslint-error\" data-tip=\"Destructuring assignment baz unnecessarily renamed.<br/><span class='eslint-error-rule-id'>eslint(no-useless-rename)</span>\">baz<span class=\"token punctuation\">:</span> baz</mark> <span class=\"token punctuation\">}</span> <span class=\"token operator\">=</span> foo<span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">import</span> <span class=\"token punctuation\">{</span> foo <span class=\"token punctuation\">}</span> <span class=\"token keyword\">from</span> <span class=\"token string\">'foo'</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">export</span> <span class=\"token punctuation\">{</span> bar <span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">let</span> <span class=\"token punctuation\">{</span> baz <span class=\"token punctuation\">}</span> <span class=\"token operator\">=</span> foo<span class=\"token punctuation\">;</span>",
"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": "<mark class=\"eslint-error\" data-tip=\"Unexpected var, use let or const instead.<br/><span class='eslint-error-rule-id'>eslint(no-var)</span>\"><span class=\"token keyword\">var</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span></mark>",
"goodExample": "<span class=\"token keyword\">let</span> foo <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> bar <span class=\"token operator\">=</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span>",
"fixable": true,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"no-void": {
"name": "no-void",
"value": "error",
"description": "禁止使用 void",
"reason": "",
"badExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <mark class=\"eslint-error\" data-tip=\"Expected &apos;undefined&apos; and instead saw &apos;void&apos;.<br/><span class='eslint-error-rule-id'>eslint(no-void)</span>\"><span class=\"token keyword\">void</span> <span class=\"token number\">0</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"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": "<mark class=\"eslint-error\" data-tip=\"Split &apos;let&apos; declarations into multiple statements.<br/><span class='eslint-error-rule-id'>eslint(one-var)</span>\"><span class=\"token keyword\">let</span> foo<span class=\"token punctuation\">,</span> bar<span class=\"token punctuation\">;</span></mark>\n<mark class=\"eslint-error\" data-tip=\"Split &apos;const&apos; declarations into multiple statements.<br/><span class='eslint-error-rule-id'>eslint(one-var)</span>\"><span class=\"token keyword\">const</span> baz <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">,</span>\n qux <span class=\"token operator\">=</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span></mark>",
"goodExample": "<span class=\"token keyword\">let</span> foo<span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">let</span> bar<span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> baz <span class=\"token operator\">=</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">const</span> qux <span class=\"token operator\">=</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span>",
"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": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Use an object spread instead of `Object.assign` eg: `{ ...foo }`.<br/><span class='eslint-error-rule-id'>eslint(prefer-object-spread)</span>\">Object<span class=\"token punctuation\">.</span><span class=\"token function\">assign</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span><span class=\"token punctuation\">,</span> bar<span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token punctuation\">{</span> <span class=\"token operator\">...</span>bar <span class=\"token punctuation\">}</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token comment\">// 第一个参数为变量时允许使用 Object.assign</span>\nObject<span class=\"token punctuation\">.</span><span class=\"token function\">assign</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">,</span> baz<span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": true,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"prefer-promise-reject-errors": {
"name": "prefer-promise-reject-errors",
"value": "error",
"description": "Promise 的 reject 中必须传入 Error 对象，而不是字面量",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Expected the Promise rejection reason to be an Error.<br/><span class='eslint-error-rule-id'>eslint(prefer-promise-reject-errors)</span>\">Promise<span class=\"token punctuation\">.</span><span class=\"token function\">reject</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">Promise</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">resolve<span class=\"token punctuation\">,</span> reject</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Expected the Promise rejection reason to be an Error.<br/><span class='eslint-error-rule-id'>eslint(prefer-promise-reject-errors)</span>\"><span class=\"token function\">reject</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">Promise</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">resolve<span class=\"token punctuation\">,</span> reject</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"Expected the Promise rejection reason to be an Error.<br/><span class='eslint-error-rule-id'>eslint(prefer-promise-reject-errors)</span>\"><span class=\"token function\">reject</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"goodExample": "Promise<span class=\"token punctuation\">.</span><span class=\"token function\">reject</span><span class=\"token punctuation\">(</span><span class=\"token keyword\">new</span> <span class=\"token class-name\">Error</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">Promise</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">(</span><span class=\"token parameter\">resolve<span class=\"token punctuation\">,</span> reject</span><span class=\"token punctuation\">)</span> <span class=\"token operator\">=></span> <span class=\"token punctuation\">{</span>\n <span class=\"token function\">reject</span><span class=\"token punctuation\">(</span><span class=\"token keyword\">new</span> <span class=\"token class-name\">Error</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"prefer-regex-literals": {
"name": "prefer-regex-literals",
"value": "error",
"description": "优先使用正则表达式字面量，而不是 RegExp 构造函数",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"Use a regular expression literal instead of the &apos;RegExp&apos; constructor.<br/><span class='eslint-error-rule-id'>eslint(prefer-regex-literals)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span><span class=\"token string\">'abc'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>\n<mark class=\"eslint-error\" data-tip=\"Use a regular expression literal instead of the &apos;RegExp&apos; constructor.<br/><span class='eslint-error-rule-id'>eslint(prefer-regex-literals)</span>\"><span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span><span class=\"token string\">'\\\\.'</span><span class=\"token punctuation\">,</span> <span class=\"token string\">'g'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token regex\">/abc/</span><span class=\"token punctuation\">;</span>\n<span class=\"token regex\">/\\./g</span><span class=\"token punctuation\">;</span>\n<span class=\"token keyword\">new</span> <span class=\"token class-name\">RegExp</span><span class=\"token punctuation\">(</span>prefix <span class=\"token operator\">+</span> <span class=\"token string\">'abc'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"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": "error",
"description": "parseInt 必须传入第二个参数",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Missing radix parameter.<br/><span class='eslint-error-rule-id'>eslint(radix)</span>\"><span class=\"token function\">parseInt</span><span class=\"token punctuation\">(</span><span class=\"token string\">'071'</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span> <span class=\"token comment\">// 57</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token function\">parseInt</span><span class=\"token punctuation\">(</span><span class=\"token string\">'071'</span><span class=\"token punctuation\">,</span> <span class=\"token number\">10</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span> <span class=\"token comment\">// 71</span>",
"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": "<mark class=\"eslint-error\" data-tip=\"This generator function does not have &apos;yield&apos;.<br/><span class='eslint-error-rule-id'>eslint(require-yield)</span>\"><span class=\"token keyword\">function</span><span class=\"token operator\">*</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">return</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span></mark>",
"goodExample": "<span class=\"token keyword\">function</span><span class=\"token operator\">*</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <span class=\"token keyword\">yield</span> <span class=\"token number\">1</span><span class=\"token punctuation\">;</span>\n <span class=\"token keyword\">return</span> <span class=\"token number\">2</span><span class=\"token punctuation\">;</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token comment\"><mark class=\"eslint-error\" data-tip=\"Expected space or tab after &apos;//&apos; in comment.<br/><span class='eslint-error-rule-id'>eslint(spaced-comment)</span>\">//foo</mark></span>\n<span class=\"token comment\"><mark class=\"eslint-error\" data-tip=\"Expected exception block, space or tab after &apos;/*&apos; in comment.<br/><span class='eslint-error-rule-id'>eslint(spaced-comment)</span>\">/*bar */</mark></span>\n<span class=\"token comment\"><mark class=\"eslint-error\" data-tip=\"Expected exception block, space or tab after &apos;/**&apos; in comment.<br/><span class='eslint-error-rule-id'>eslint(spaced-comment)</span>\">/**baz */</mark></span>",
"goodExample": "<span class=\"token comment\">// foo</span>\n<span class=\"token comment\">/* bar */</span>\n<span class=\"token comment\">/** baz */</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"strict": {
"name": "strict",
"value": ["error", "never"],
"description": "禁止使用 'strict';",
"reason": "",
"badExample": "<mark class=\"eslint-error\" data-tip=\"&apos;use strict&apos; is unnecessary inside of modules.<br/><span class='eslint-error-rule-id'>eslint(strict)</span>\"><span class=\"token string\">'use strict'</span><span class=\"token punctuation\">;</span></mark>\n<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n <mark class=\"eslint-error\" data-tip=\"&apos;use strict&apos; is unnecessary inside of modules.<br/><span class='eslint-error-rule-id'>eslint(strict)</span>\"><span class=\"token string\">'use strict'</span><span class=\"token punctuation\">;</span></mark>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">function</span> <span class=\"token function\">foo</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span><span class=\"token punctuation\">}</span>",
"fixable": true,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"symbol-description": {
"name": "symbol-description",
"value": "error",
"description": "创建 Symbol 时必须传入参数",
"reason": "",
"badExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <mark class=\"eslint-error\" data-tip=\"Expected Symbol to have a description.<br/><span class='eslint-error-rule-id'>eslint(symbol-description)</span>\"><span class=\"token function\">Symbol</span><span class=\"token punctuation\">(</span><span class=\"token punctuation\">)</span></mark><span class=\"token punctuation\">;</span>",
"goodExample": "<span class=\"token keyword\">const</span> foo <span class=\"token operator\">=</span> <span class=\"token function\">Symbol</span><span class=\"token punctuation\">(</span><span class=\"token string\">'foo'</span><span class=\"token punctuation\">)</span><span class=\"token punctuation\">;</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"use-isnan": {
"name": "use-isnan",
"value": "error",
"description": "必须使用 isNaN(foo) 而不是 foo === NaN",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Use the isNaN function to compare with NaN.<br/><span class='eslint-error-rule-id'>eslint(use-isnan)</span>\">foo <span class=\"token operator\">===</span> <span class=\"token number\">NaN</span></mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token function\">isNaN</span><span class=\"token punctuation\">(</span>foo<span class=\"token punctuation\">)</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"fixable": false,
"extendsBaseRule": "",
"requiresTypeChecking": false
},
"valid-typeof": {
"name": "valid-typeof",
"value": "error",
"description": "typeof 表达式比较的对象必须是 'undefined', 'object', 'boolean', 'number', 'string', 'function', 'symbol', 或 'bigint'",
"reason": "",
"badExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token keyword\">typeof</span> foo <span class=\"token operator\">===</span> <span class=\"token string\"><mark class=\"eslint-error\" data-tip=\"Invalid typeof comparison value.<br/><span class='eslint-error-rule-id'>eslint(valid-typeof)</span>\">'numbe'</mark></span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token keyword\">typeof</span> foo <span class=\"token operator\">===</span> <span class=\"token string\">'number'</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"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": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><mark class=\"eslint-error\" data-tip=\"Expected literal to be on the right side of ===.<br/><span class='eslint-error-rule-id'>eslint(yoda)</span>\"><span class=\"token number\">1</span> <span class=\"token operator\">===</span> foo</mark><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"goodExample": "<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span>foo <span class=\"token operator\">===</span> <span class=\"token number\">1</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token number\">1</span> <span class=\"token operator\"><</span> foo<span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>\n<span class=\"token keyword\">if</span> <span class=\"token punctuation\">(</span><span class=\"token number\">1</span> <span class=\"token operator\"><</span> foo <span class=\"token operator\">&&</span> foo <span class=\"token operator\"><</span> <span class=\"token number\">10</span><span class=\"token punctuation\">)</span> <span class=\"token punctuation\">{</span>\n<span class=\"token punctuation\">}</span>",
"fixable": true,
"extendsBaseRule": "",
"requiresTypeChecking": false
}
}