eslint规则总结

"off" or 0 - 关闭规则
"warn" or 1 - 将规则视为一个警告（不会影响退出码）
"error" or 2 - 将规则视为一个错误 (退出码为1)
no-constant-condition  不允许常量条件表达式
no-cond-assign     禁止条件表达式中出现赋值操作符
prefer-const   没有再赋值的变量 只能使用const
no-unused-vars   申明但没有调用
indent  ["error", 2]  代表每次换行代码 都得加两个空格
no-var  不能用var
no-multiple-empty-lines: [2, { max: 2 }]  语句之间空行不能超过2
import/first   import语句需要置顶搁置
for-direction  for不能无限循环
no-trailing-spaces  禁止行尾空格
no-empty    禁止使用空语句模块   if，switch，for，try，catch的{内没有内容}
getter-return   {get name(){}};  get下需要加return语句
no-async-promise-executor  await new Promise(async function(){})
                            这里的await和async都不能使用 
no-undef    禁止未定义餐数
no-await-in-loop  禁止循环中出现await
space-before-function-paren: ["error", {   函数圆括号之前有空格
        "anonymous": "always/never/ignore",    function () {}
        "named": "always/never/ignore",           function foo () {}
        "asyncArrow": "always/never/ignore"      async () => {}
}],
no-compare-neg-zero     警告 x === -0,不能喝-0做比较
no-console    	禁用 console
no-control-regex    /\x1f/   禁止在正则表达式中使用控制字符
在 ASCII 中，0-31 范围内的控制字符是特殊的、不可见的字符。这些字符很少被用在 JavaScript 	字符串中    
no-debugger   禁用 debugger
no-dupe-args   function foo(a, a) {  }  禁止 function 定义中出现重名参数	
no-dupe-keys   禁止对象出现重复的 key   {a:1,a:2}	
no-duplicate-case   禁止出现重复的 case 标签	
no-empty-character-class   /^abc[]/   禁止在正则表达式中使用空字符集 	
no-ex-assign     禁止对 catch 子句的参数重新赋值   catch (e) { e = 10;}	
no-extra-boolean-cast   	禁止不必要的布尔转换
no-extra-parens       禁止不必要的括号	
no-extra-semi     	禁止不必要的分号 var x = 5;;	
no-func-assign         禁止对 function 声明重新赋值  function foo() {}   foo = bar;
no-inner-declarations: [2, "both/functions"],	禁止在嵌套的块中 ,出现变量声明或 function 声明
"functions" (默认) 禁止 function 声明出现在嵌套的语句块中
"both" 禁止 function 和 var 声明出现在嵌套的语句块中
if (test) {
 	 function doSomethingElse() {}   错
}
var b = function() {
  var fn;
  if (test) {
      fn = function() {};    对
      var a=1;   错
      	     function declaration() {}；   错
  }
};
no-invalid-regexp	禁止 RegExp 构造函数中存在无效的正则表达式字符串
no-irregular-whitespace	禁止不规则的空白
no-misleading-character-class	不允许在字符类语法中出现由多个代码点组成的字符
no-obj-calls	     禁止把全局对象作为函数调用
var math = Math();
var json = JSON();
var reflect = Reflect();
no-prototype-builtins	禁止直接调用 Object.prototypes 的内置属性
var hasBarProperty = foo.hasOwnProperty("bar"); 错
var hasBarProperty = Object.prototype.hasOwnProperty.call(foo, "bar");对
no-regex-spaces	禁止正则表达式字面量中出现多个空格
 /foo  bar/;错
 /foo {3}bar/;对
no-sparse-arrays	禁用稀疏数组
逗号之前没有任何元素的数组。该规则不适用于紧随最后一个元素的拖尾逗号的情况。
var items = [,];
var colors = [ "red",, "blue" ];
no-template-curly-in-string	禁止在常规字符串中出现模板字面量占位符语法
"Hello ${name}!";错
`Hello ${name}!`;对
no-unexpected-multiline	禁止出现令人困惑的多行表达式
var foo = bar
(1 || 2).baz();错

var foo = bar;
(1 || 2).baz();对
no-unreachable	    禁止在 return、throw、continue 和 break 语句之后出现不可达代码
return true;
console.log("done");
throw new Error("Oops!");
console.log("done");
break;
console.log("done");
no-unsafe-finally	 禁止在 finally 语句块中出现控制流语句 return、throw、break 和 continue
try {return 1;} 
catch(err) {return 2;} 
finally {return 3;}

no-unsafe-negation	禁止对关系运算符的左操作数使用否定操作符
 if (!key in object) {}错
if (!(key in object)) {}对
if (!obj instanceof Ctor) {}错
if (!(obj instanceof Ctor)) {}对
require-atomic-updates  禁止由于 await  或 yield的使用而可能导致出现竞态条件的赋值
let result;
async function foo() {错
  result += await somethingElse;
  result = result + await somethingElse;
  result = result + doSomething(await somethingElse);
}

let result;
async function foo() {对
  result = await somethingElse + result;
  let tmp = await somethingElse;
  result += tmp;
  let localVariable = 0;
  localVariable += await somethingElse;
}
use-isnan 	要求使用 isNaN() 检查 NaN
if (foo == NaN) {  错
    // ...
}
if (isNaN(foo)) {  对
    // ...
}
valid-typeof	强制 typeof 表达式与有效的字符串进行比较
typeof foo === "strnig"         错
typeof foo == "undefimed"   错
typeof bar != "nunber"        错
typeof bar !== "fucntion"     错

typeof foo === "string"          对
typeof bar == "undefined"     对
typeof foo === baz               对
typeof bar === typeof qux   对


accessor-pairs   		强制 getter 和 setter 在对象中成对出现

array-callback-return	强制数组方法的回调函数中有 return 语句

block-scoped-var		强制把变量的使用限制在其定义的作用域范围内

class-methods-use-this	强制类方法使用 this

complexity: 0			指定程序中允许的最大环路复杂度

consistent-return		要求 return 语句要么总是指定返回的值，要么都不指定
function doSomething(condition) {
    if (condition) {
        return true;
    } else {
        return;错
    }
}


curly			强制所有控制语句使用一致的括号风格
if (foo) foo++;
while (bar)
    baz();
if (foo) {
    baz();
} else qux();

default-case	要求 switch 语句中有 default 分支

dot-location	强制在点号之前和之后一致的换行	
值是 "object" (默认)，点和对象在同一行。
值是 "property"，点和属性在同一行。
var foo = object
.property;
dot-notation	强制尽可能地使用点号
var x = foo["bar"];   当可以用foo.bar取值时 会报错 错
var x = foo[bar]; // bar 是可变的  这个对

eqeqeq:['error','always',{'null':'always/never/ignore'}]  
eqeqeq:['error','smart']  除了 比较两个字面量的值 、比较 typeof 的值 、null 进行比较 外，强制全等
       要求使用 === 和 !==
[] == false
[] == ![]
3 == "03"  看上去是无害的，但实际的问题是很难被发现的。
guard-for-in	要求 for-in 循环中有一个 if 语句
for (key in foo) {
    if (Object.prototype.hasOwnProperty.call(foo, key)) {
        doSomething(key);
    }
}

max-classes-per-file:["error", 1]	每个文件中的类的最大数量为1个

no-alert		禁用 alert、confirm 和 prompt

no-caller		禁用 arguments.caller 或 arguments.callee

no-case-declarations	不允许在 case 子句中使用词法声明
该规则禁止词法声明 (let、const、function 和 class) 出现在 case或default 子句中
switch (foo) {
    case 1:
        let x = 1;
        break;
    case 2:
        const y = 2;
        break;
    case 3:
        function f() {}
        break;
    default:
        class C {}
}  错

switch (foo) {
    // The following case clauses are wrapped into blocks using brackets
    case 1: {
        let x = 1;
        break;
    }
    case 2: {
        const y = 2;
        break;
    }
    case 3: {
        function f() {}
        break;
    }
    case 4:
         var z = 4;
        break;
    default: {
        class C {}
    }
}对

no-div-regex			禁止除法操作符显式的出现在正则表达式开始的位置

no-else-return		禁止 if 语句中 return 语句之后有 else 块

no-empty-function	禁止出现空函数

no-empty-pattern		禁止使用空解构模式
var {} = foo;  	   错
var [] = foo;	   错
var {a: {}} = foo;  错
var {a: []} = foo;   错
function foo({}) {}  错
function foo([]) {}  错
function foo({a: {}}) {}错
function foo({a: []}) {}错

var {a = {}} = foo;	  对
var {a = []} = foo;	  对
function foo({a = {}}) {}对
function foo({a = []}) {}对

no-eq-null		禁止在没有类型检查操作符的情况下与 null 进行比较

no-eval			禁用 eval()

no-extend-native	禁止扩展原生类型

no-extra-bind		禁止不必要的 .bind() 调用

no-extra-label	禁用不必要的标签

no-fallthrough		禁止 case 语句落空

switch(foo) {错
    case 1:
        doSomething();
    case 2:
        doSomething();
}
switch(foo) {//对
    case 1:
        doSomething();
        // falls through
    case 2:
        doSomething();
}

no-floating-decimal		禁止数字字面量中使用前导和末尾小数点

no-global-assign		禁止对原生对象或只读的全局对象进行赋值

no-implicit-coercion		禁止使用短符号进行类型转换

no-implicit-globals		禁止在全局范围内使用变量声明和 function 声明

no-implied-eval		禁止使用类似 eval() 的方法

no-invalid-this			禁止 this 关键字出现在类和类对象之外

no-iterator			禁用 __iterator__ 属性
	
no-labels				禁用标签语句
no-lone-blocks禁用不必要的嵌套块

no-loop-func禁止在循环语句中出现包含不安全引用的函数声明

no-magic-numbers禁用魔术数字

no-multi-spaces禁止使用多个空格

no-multi-str禁止使用多行字符串

no-new禁止使用 new 以避免产生副作用

no-new-func禁止对 Function 对象使用 new 操作符

no-new-wrappers禁止对 String，Number 和 Boolean 使用 new 操作符

no-octal禁用八进制字面量

no-octal-escape禁止在字符串中使用八进制转义序列

no-param-reassign禁止对 function 的参数进行重新赋值

no-proto禁用 __proto__ 属性

no-redeclare禁止多次声明同一变量

no-restricted-properties禁止使用对象的某些属性

no-return-assign禁止在 return 语句中使用赋值语句

no-return-await禁用不必要的 return await

no-script-url禁止使用 javascript: url

no-self-assign禁止自我赋值

no-self-compare禁止自身比较

no-sequences禁用逗号操作符

no-throw-literal禁止抛出异常字面量

no-unmodified-loop-condition禁用一成不变的循环条件

no-unused-expressions禁止出现未使用过的表达式

no-unused-labels禁用出现未使用过的标

no-useless-call禁止不必要的 .call() 和 .apply()

no-useless-catch禁止不必要的 catch 子句

no-useless-concat禁止不必要的字符串字面量或模板字面量的连接

no-useless-escape禁用不必要的转义字符

no-useless-return禁止多余的 return 语句

no-void禁用 void 操作符

no-warning-comments禁止在注释中使用特定的警告术语

no-with禁用 with 语句

prefer-named-capture-group建议在正则表达式中使用命名捕获组

prefer-promise-reject-errors要求使用 Error 对象作为 Promise 拒绝的原因

radix强制在 parseInt() 使用基数参数

require-await禁止使用不带 await 表达式的 async 函数

require-unicode-regexp强制在 RegExp 上使用 u 标志

vars-on-top要求所有的 var 声明出现在它们所在的作用域顶部

wrap-iife要求 IIFE 使用括号括起来

yoda要求或禁止 “Yoda” 条件