Eslint(二)：规则字典

字数：6190

阅读时间：30分钟

Standard规范+Angular规范集合

代码格式

indent

"indent": ["error", 4]

规定使用几个空格进行缩进。第二个参数表示空格的个数，默认是2个，我们这个设置的是四格。

block-spacing

"block-spacing": ["error", "always"]

规定单行代码两边加空格。第二个参数有"always"、"never"，默认值为"always"，表示需要至少一个空格，"never"表示不需要空格。代码示例如下：

function foo () {return true}    // ✗ avoid
function foo () { return true }  // ✓ ok

brace-style

"brace-style": ["error", "1tbs", { "allowSingleLine": true }]

规定 “else” 关键字要与花括号保持在同一行。第二个参数表示不同的规则风格，可取"1tbs"、“stroustrup”、“allman”三种风格。第三个参数表示是否允许大括号在同一行，默认值为 “false”。代码示例如下：

// ✓ ok
if (condition) {
  // ...
} else {
  // ...
}


// ✗ avoid
if (condition)
{
  // ...
}
else
{
  // ...
}

comma-spacing

"comma-spacing": ["error", { "before": false, "after": true }]

规定逗号后面必须添加空格。第二个参数用来设置逗号前和逗号后是否添加空格。代码示例如下：

// ✓ ok
var list = [1, 2, 3, 4]
function greet (name, options) { ... }

// ✗ avoid
var list = [1,2,3,4]
function greet (name,options) { ... }

curly

"curly": ["error", "multi-line"]

规定多行 if 语句的的括号不能省略。第二个参数配置那些场景会报错，可取值“all”、“multi”、“multi-line”、“multi-or-nest”、“consistent”。这里“multi-line”表示多行代码不能省略。代码示例如下：

// ✓ ok
if (options.quiet !== true) console.log('done')

// ✓ ok
if (options.quiet !== true) {
  console.log('done')
}

// ✗ avoid
if (options.quiet !== true)
  console.log('done')

dot-location

"dot-location": ["error", "property"]

规定点号操作符须与属性需在同一行。第二个参数配置点的位置，取值“property”和“object”。“property”表示点与属性同一行，“object”表示点与对象同一行。代码示例如下：

  console.
    log('hello')  // ✗ avoid

  console
    .log('hello') // ✓ ok

eol-last

"eol-last": "error"

规定文件末尾空一行，以防文件解析错误。

func-call-spacing

"func-call-spacing": ["error", "never"]

规定函数调用时标识符与括号间不留间隔。第二个参数取值“never”和“always”，"never"表不留空格，"always"表要留空格。代码示例如下：

console.log ('hello') // ✗ avoid
console.log('hello')  // ✓ ok

key-spacing

"key-spacing": ["error", { "beforeColon": false, "afterColon": true }]

规定键值对中冒号与值之间要留空白。第二个参数配置前后是否留白。示例代码如下：

var obj = { 'key' : 'value' }    // ✗ avoid
var obj = { 'key' :'value' }     // ✗ avoid
var obj = { 'key':'value' }      // ✗ avoid
var obj = { 'key': 'value' }     // ✓ ok

no-mixed-spaces-and-tabs

"no-mixed-spaces-and-tabs": "error"

规定不能混合使用空格与制表符作为缩进。

no-multi-spaces

"no-multi-spaces": "error"

规定除了缩进，不要使用多个空格。代码示例如下：

const id =    1234    // ✗ avoid
const id = 1234       // ✓ ok

no-multiple-empty-lines

"no-multiple-empty-lines": ["error", { "max": 1, "maxEOF": 0 }]

规定不允许有连续多行空行且文件头部不允许空行。第二个参数是一个对象，里面有三个属性。“max”属性表连续空行数，“maxEOF”表文件结尾空行数，“maxBOF”表示文件开头空行数。

no-trailing-spaces

"no-trailing-spaces": "error"

规定行末不留空格。

no-whitespace-before-property

"no-whitespace-before-property": "error"

规定属性前面不能加空格。

object-property-newline

"object-property-newline": ["error", { "allowMultiplePropertiesPerLine": true }]

规定对象属性换行时注意统一代码风格(要么都换行，要么都不换)。第二个参数是一个对象，配置是否允许在一行代码中书写多个属性。代码示例如下：

const user = {
  name: 'Jane Doe', age: 30,
  username: 'jdoe86'            // ✗ avoid
}

const user = { name: 'Jane Doe', age: 30, username: 'jdoe86' }    // ✓ ok

const user = {
  name: 'Jane Doe',
  age: 30,
  username: 'jdoe86'
}

operator-linebreak

"operator-linebreak": ["error", "after", { "overrides": { "?": "before", ":": "before" } }]

规定对于三元运算符 ? 和 : 与他们所负责的代码处于同一行。第二个参数配置换行符位置，可配“after”、“before”、“none”,分别表示操作符之后可换行，操作符之前可换行，前后都不允许换行。第三个参数配置覆盖第二个参数的配置内容。代码示例如下：

// ✓ ok
var location = env.development ? 'localhost' : 'www.api.com'

// ✓ ok
var location = env.development
  ? 'localhost'
  : 'www.api.com'

// ✗ avoid
var location = env.development ?
  'localhost' :
  'www.api.com'

padded-blocks

"padded-blocks": ["error", { "blocks": "never", "switches": "never", "classes": "never" }]

规则定义代码中不要啊出现多余留白。第二个参数是一个对象，有以下属性配置。“blocks”表代码块，“classes”表类，“switches”表switch语句，取值都为“never”或“always”，表示是否需要留空行。代码示例如下：

if (user) {
                            // ✗ avoid
  const name = getName()

}

if (user) {
  const name = getName()    // ✓ ok
}

rest-spread-spacing

"rest-spread-spacing": ["error", "never"]

规定展开运算符与它的表达式间不要留空白。第二个参数取值“never”和“always”，表是否需要留白。代码示例如下：

fn(... args)    // ✗ avoid
fn(...args)     // ✓ ok

semi-spacing

"semi-spacing": ["error", { "before": false, "after": true }]

规定分号前不留空格，后面留一个空格。第二个参数就是配置前后空格开关的。代码示例如下：

for (let i = 0 ;i < items.length ;i++) {...}    // ✗ avoid
for (let i = 0; i < items.length; i++) {...}    // ✓ ok

space-before-blocks

"space-before-blocks": ["error", "always"]

规定代码块收尾需留空格。第二个参数配置是否需要空格。代码示例如下：

if (admin){...}     // ✗ avoid
if (admin) {...}    // ✓ ok

space-before-function-paren

"space-before-function-paren": ["error", "always"]

规定函数声明时括号与函数名间加空格。第二个参数配置是否需要空格。代码示例如下：

function name (arg) { ... }   // ✓ ok
function name(arg) { ... }    // ✗ avoid

run(function () { ... })      // ✓ ok
run(function() { ... })       // ✗ avoid

space-in-parens

"space-in-parens": ["error", "never"]

规定圆括号间不留空格。第二个参数配置是否需要空格。代码示例如下：

getName( name )     // ✗ avoid
getName(name)       // ✓ ok

space-infix-ops

"space-infix-ops": "error"

规定字符串拼接操作符 (Infix operators) 之间要留空格。代码示例如下:

// ✓ ok
var x = 2
var message = 'hello, ' + name + '!'

// ✗ avoid
var x=2
var message = 'hello, '+name+'!'

space-unary-ops

"space-unary-ops": ["error", { "words": true, "nonwords": false }]

规定文字格式的一元运算符后跟一个空格。第二个参数有三个属性，“words”表文字格式的运算符（new，delete，typeof，void，yield），"nonwords"表非文字运算符（-,+,--,++,!,!!）,"overrides"配置一个对象值，配置具体操作符的空格行为。代码示例如下：

typeof!admin        // ✗ avoid
typeof !admin        // ✓ ok

template-curly-spacing

"template-curly-spacing": ["error", "never"]

规定模板字符串中变量前后不加空格。第二个参数配置是否需要空格。代码示例如下：

const message = `Hello, ${ name }`    // ✗ avoid
const message = `Hello, ${name}`      // ✓ ok

yield-star-spacing

"yield-star-spacing": ["error", "both"]

规定yield 中的前后都要有空格。第二个参数取值“before”、“after”、“both”、“neither”，分别表示前留、后留、都留和都不留。代码示例如下：

yield* increment()    // ✗ avoid
yield * increment()   // ✓ ok

generator-star-spacing

"generator-star-spacing": ["error", { "before": true, "after": true }]

规定生成器函数*的前后都要留空格。

可能出错代码

accessor-pairs

"accessor-pairs": "error"

规定get和set成对出现。代码示例如下：

var person = {
  set name (value) {    // ✗ avoid
    this.name = value
  }
}

var person = {
  set name (value) {
    this.name = value
  },
  get name () {         // ✓ ok
    return this.name
  }
}

comma-dangle

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

规定不允许多余的行末逗号。第二个参数可配置属性，“arrays”、“objects”、“imports”、“exports”、“functions”，值分别取“never”或“always”。代码示例如下：

 var obj = {
    message: 'hello',   // ✗ avoid
  }

comma-style

"comma-style": ["error", "last"]

规定始终将逗号置于行末。第二个参数取值“last”或“first”，分别表示行末或行首。代码示例如下：

  var obj = {
    foo: 'foo'
    ,bar: 'bar'   // ✗ avoid
  }

  var obj = {
    foo: 'foo',
    bar: 'bar'   // ✓ ok
  }

constructor-super

"constructor-super": "error"

规定子类构造函数中必须调用super，非子类不要调用super。代码示例如下：

class Dog {
  constructor () {
    super()   // ✗ avoid
  }
}

class Dog extends Mammal {
  constructor () {
    super()   // ✓ ok
  }
}

eqeqeq

"eqeqeq": ["error", "always", { "null": "ignore" }]

规定始终使用 === 替代 ==，null除外。第二个参数配置是否使用 === ，第三个参数配置是否忽略空值判断。示例代码如下：

if (name === 'John')   // ✓ ok
if (name == 'John')    // ✗ avoid
if (name !== 'John')   // ✓ ok
if (name != 'John')    // ✗ avoid

handle-callback-err

"handle-callback-err": ["error", "^(err|error)$" ]

规定函数里面的异常信息不要忘记处理。第二个参数配置匹配那些参数的正则表达式。示例代码如下：

// ✓ ok
run(function (err) {
  if (err) throw err
  window.alert('done')
})

// ✗ avoid
run(function (err) {
  window.alert('done')
})

new-parens

"new-parens": "error"

规定无参的构造函数调用时要带上括号。代码示例如下：

function Animal () {}
var dog = new Animal    // ✗ avoid
var dog = new Animal()  // ✓ ok

no-array-constructor

"no-array-constructor": "error"

规定使用数组字面量而不是构造器(由于参数的二义性)，但是我们可以在初始化一个固定大小数组时用到他。代码示例如下：

var nums = new Array(1, 2, 3)   // ✗ avoid
var nums = [1, 2, 3]            // ✓ ok

no-class-assign

"no-class-assign": "error"

规定避免对类名重新赋值。代码示例如下：

class Dog {}
Dog = 'Fido'    // ✗ avoid

no-const-assign

"no-const-assign": "error"

规定避免修改使用 const 声明的变量。代码示例如下：

const score = 100
score = 125       // ✗ avoid

no-constant-condition

"no-constant-condition": ["error", { "checkLoops": false }]

规定避免使用常量作为条件表达式的条件（循环语句除外）。第二个参数配置是否检查循环表达式。代码示例如下：

if (false) {    // ✗ avoid
  // ...
}

if (x === 0) {  // ✓ ok
  // ...
}

while (true) {  // ✓ ok
  // ...
}

no-delete-var

"no-delete-var": "error"

规定不要对变量使用 delete 操作。代码示例如下：

var name
delete name     // ✗ avoid

no-dupe-args

"no-dupe-args": "error"

规定不要定义重复的函数参数。代码示例如下：

function sum (a, b, a) {  // ✗ avoid
  // ...
}

function sum (a, b, c) {  // ✓ ok
  // ...
}

no-dupe-class-members

"no-dupe-class-members": "error"

规定类中不要定义重复的属性。代码示例如下：

class Dog {
  bark () {}
  bark () {}    // ✗ avoid
}

no-dupe-keys

"no-dupe-keys": "error"

规定对象字面量中不要定义重复的属性。代码示例如下：

var user = {
  name: 'Jane Doe',
  name: 'John Doe'    // ✗ avoid
}

no-duplicate-case

"no-duplicate-case": "error"

规定switch 语句中不要定义重复的 case 分支。代码示例如下：

switch (id) {
  case 1:
    // ...
  case 1:     // ✗ avoid
}

no-empty-character-class

"no-empty-character-class": "error"

规定正则中不要使用空字符。代码示例如下：

const myRegex = /^abc[]/      // ✗ avoid
const myRegex = /^abc[a-z]/   // ✓ ok

no-empty-pattern

"no-empty-pattern": "error"

规定不要解构空值。代码示例如下：

const { a: {} } = foo         // ✗ avoid
const { a: { b } } = foo      // ✓ ok

no-ex-assign

"no-ex-assign": "error"

定义catch 中不要对错误重新赋值。代码示例如下：

try {
  // ...
} catch (e) {
  e = 'new value'             // ✗ avoid
}

try {
  // ...
} catch (e) {
  const newVal = 'new value'  // ✓ ok
}

no-fallthrough

"no-fallthrough": "error"

规定switch一定要使用 break 来将条件分支正常中断。代码示例如下：

switch (filter) {
  case 1:
    doSomething()    // ✗ avoid
  case 2:
    doSomethingElse()
}

switch (filter) {
  case 1:
    doSomething()
    break           // ✓ ok
  case 2:
    doSomethingElse()
}

switch (filter) {
  case 1:
    doSomething()
    // fallthrough  // ✓ ok
  case 2:
    doSomethingElse()
}

no-func-assign

"no-func-assign": "error"

规定避免对声明过的函数重新赋值。代码示例如下：

function myFunc () { }
myFunc = myOtherFunc    // ✗ avoid

no-global-assign

"no-global-assign": "error"

规定不要对全局只读对象重新赋值。代码示例如下：

window = {}     // ✗ avoid

no-invalid-regexp

"no-invalid-regexp": "error"

规定不要向 RegExp 构造器传入非法的正则表达式。代码示例如下：

RegExp('[a-z')    // ✗ avoid
RegExp('[a-z]')   // ✓ ok

no-iterator

"no-iterator": "error"

规定禁止使用 __iterator__。代码示例如下：

Foo.prototype.__iterator__ = function () {}   // ✗ avoid

no-self-assign

"no-self-assign": "error"

规定避免将变量赋值给自己。代码示例如下：

name = name   // ✗ avoid

no-self-compare

"no-self-compare": "error"

规定避免将变量与自己进行比较操作。代码示例如下：

if (score === score) {}   // ✗ avoid

no-shadow-restricted-names

"no-shadow-restricted-names": "error"

规定禁止随意更改关键字的值。代码示例如下：

let undefined = 'value'     // ✗ avoid

no-sparse-arrays

"no-sparse-arrays": "error"

规定禁止使用稀疏数组。代码示例如下：

let fruits = ['apple',, 'orange']       // ✗ avoid

no-template-curly-in-string

"no-template-curly-in-string": "error"

规定正确使用 ES6 中的字符串模板。代码示例如下：

const message = 'Hello ${name}'   // ✗ avoid
const message = `Hello ${name}`   // ✓ ok

no-throw-literal

"no-throw-literal": "error"

规定用throw 抛错时，抛出 Error 对象而不是字符串。代码示例如下：

throw 'error'               // ✗ avoid
throw new Error('error')    // ✓ ok

no-unexpected-multiline

"no-unexpected-multiline": "error"

规定不要使用 (, [, or ` 等作为一行的开始。在没有分号的情况下代码压缩后会导致报错，而坚持这一规范则可避免出错。代码示例如下：

// ✓ ok
;(function () {
  window.alert('ok')
}())

// ✗ avoid
(function () {
  window.alert('ok')
}())

// ✓ ok
;[1, 2, 3].forEach(bar)

// ✗ avoid
[1, 2, 3].forEach(bar)

// ✓ ok
;`hello`.indexOf('o')

// ✗ avoid
`hello`.indexOf('o')

no-unmodified-loop-condition

"no-unmodified-loop-condition": "error"

规定循环语句中注意更新循环变量。代码示例如下：

for (let i = 0; i < items.length; j++) {...}    // ✗ avoid
for (let i = 0; i < items.length; i++) {...}    // ✓ ok

no-unreachable

"no-unreachable": "error"

规定return，throw，continue 和 break 后不要再跟代码。代码示例如下：

function doSomething () {
  return true
  console.log('never called')     // ✗ avoid
}

no-unsafe-finally

"no-unsafe-finally": "error"

规定finally 代码块中不要再改变程序执行流程。代码示例如下：

try {
  // ...
} catch (e) {
  // ...
} finally {
  return 42     // ✗ avoid
}

valid-typeof

"valid-typeof": ["error", { "requireStringLiterals": true }]

规定用合法的字符串跟 typeof 进行比较操作。第二个参数配置是否只和字符串比对。代码示例如下：

typeof name === 'undefimed'     // ✗ avoid
typeof name === 'undefined'     // ✓ ok
typeof bar == Object           // ✗ avoid

no-control-regex

"no-control-regex": "error"

规定禁止在正则表达式中使用控制字符。代码示例如下：

var pattern = /\x1f/    // ✗ avoid
var pattern = /\x20/    // ✓ ok

no-unused-expressions

"no-unused-expressions": ["error", { "allowShortCircuit": true, "allowTernary": true, "allowTaggedTemplates": true }]

规定禁止无用的表达式。

no-use-before-define

"no-use-before-define": ["error", { "functions": false, "classes": false, "variables": false }]

规定未定义前不能使用。

最佳实践

accessor-pairs

"accessor-pairs": "error"

对象中定义了存值器，一定要定义对应的取值器。代码示例如下：

var person = {
  set name (value) {    // ✗ avoid
    this.name = value
  }
}

var person = {
  set name (value) {
    this.name = value
  },
  get name () {         // ✓ ok
    return this.name
  }
}

no-caller

"no-caller": "error"

规定避免使用 arguments.callee 和 arguments.caller（不利于代码优化，且高级版本的ES标准会废弃它）。代码示例如下：

function foo (n) {
  if (n <= 0) return

  arguments.callee(n - 1)   // ✗ avoid
}

function foo (n) {
  if (n <= 0) return

  foo(n - 1)
}

no-cond-assign

"no-cond-assign": "error"

规定条件语句中赋值语句使用括号包起来。代码示例如下：

// ✓ ok
while ((m = text.match(expr))) {
  // ...
}

// ✗ avoid
while (m = text.match(expr)) {
  // ...
}

no-debugger

"no-debugger": "error"

规定不要使用 debugger。

no-eval

"no-eval": "error"

规定不要使用 eval()。

no-extend-native

"no-extend-native": "error"

规定不要扩展原生对象。

no-extra-bind

"no-extra-bind": "error"

规定避免多余的函数上下文绑定。代码示例如下：

const name = function () {
  getName()
}.bind(user)    // ✗ avoid

const name = function () {
  this.getName()
}.bind(user)    // ✓ ok

no-extra-boolean-cast

"no-extra-boolean-cast": "error"

规定避免不必要的布尔转换。代码示例如下：

const result = true
if (!!result) {   // ✗ avoid
  // ...
}

const result = true
if (result) {     // ✓ ok
  // ...
}

no-extra-parens

"no-extra-parens": ["error", "functions"]

规定不要使用多余的括号包裹函数。第二个参数取值“all”或“functions”，表控制范围。代码示例如下：

const myFunc = (function () { })   // ✗ avoid
const myFunc = function () { }     // ✓ ok

no-floating-decimal

"no-floating-decimal": "error"

规定不要省去小数点前面的0（增强可读性）。代码示例如下：

const discount = .5      // ✗ avoid
const discount = 0.5     // ✓ ok

no-implied-eval

"no-implied-eval": "error"

规定避免使用隐式的 eval()。代码示例如下：

setTimeout("alert('Hello world')")                   // ✗ avoid
setTimeout(function () { alert('Hello world') })     // ✓ ok

no-inner-declarations

"no-inner-declarations": ["error", "functions"]

规定嵌套的代码块中禁止再定义函数。第二个参数配置控制范围，取值“both”（functions+var）、“functions”。代码示例如下：

if (authenticated) {
  function setAuthUser () {}    // ✗ avoid
}

no-irregular-whitespace

"no-irregular-whitespace": "error"

规定不要使用非法的空白符。代码示例如下：

function myFunc () /**/{}   // ✗ avoid

no-labels

"no-labels": ["error", { "allowLoop": false, "allowSwitch": false }]

规定不要使用标签语句。第二个参数含两个属性，“allowLoop”配置是否在循环语句中禁用，“allowSwitch”配置是否在switch语句中禁用。代码示例如下：

label:
  while (true) {
    break label     // ✗ avoid
  }

no-lone-blocks

"no-lone-blocks": "error"

规定不要书写不必要的嵌套代码块。代码示例如下：

function myFunc () {
  {                   // ✗ avoid
    myOtherFunc()
  }
}

function myFunc () {
  myOtherFunc()       // ✓ ok
}

no-multi-str

"no-multi-str": "error"

规定不要使用多行字符串。代码示例如下：

const message = 'Hello \
                 world'     // ✗ avoid

no-new

"no-new": "error"

规定new 创建对象实例后需要赋值给变量。代码示例如下：

new Character()                     // ✗ avoid
const character = new Character()   // ✓ ok

no-new-func

"no-new-func": "error"

规定禁止使用 Function 构造器。代码示例如下：

var sum = new Function('a', 'b', 'return a + b')    // ✗ avoid

no-new-object

"no-new-object": "error"

规定禁止使用 Object 构造器，直接声明对象即可。代码示例如下：

let config = new Object()   // ✗ avoid

no-new-require

"no-new-require": "error"

规定禁止使用 new require。代码示例如下：

const myModule = new require('my-module')    // ✗ avoid

no-new-symbol

"no-new-symbol": "error"

规定禁止使用 Symbol 构造器。代码示例如下：

const foo = new Symbol('foo')   // ✗ avoid

no-new-wrappers

"no-new-wrappers": "error"

规定禁止使用原始包装器。代码示例如下：

const message = new String('hello')   // ✗ avoid

no-obj-calls

"no-obj-calls": "error"

规定不要将全局对象的属性作为函数调用。代码示例如下：

const math = Math()   // ✗ avoid

no-octal

"no-octal": "error"

规定不要使用八进制字面量。代码示例如下：

const num = 042     // ✗ avoid
const num = '042'   // ✓ ok

no-octal-escape

"no-octal-escape": "error"

规定字符串字面量中也不要使用八进制转义字符。代码示例如下：

const copyright = 'Copyright \251'  // ✗ avoid

no-proto

"no-proto": "error"

规定使用 getPrototypeOf 来替代 __proto__。代码示例如下：

const foo = obj.__proto__               // ✗ avoid
const foo = Object.getPrototypeOf(obj)  // ✓ ok

no-redeclare

"no-redeclare": "error"

规定不要重复声明变量。代码示例如下：

let name = 'John'
let name = 'Jane'     // ✗ avoid

let name = 'John'
name = 'Jane'         // ✓ ok

no-regex-spaces

"no-regex-spaces": "error"

规定正则中避免使用多个空格。代码示例如下：

const regexp = /test   value/   // ✗ avoid

const regexp = /test {3}value/  // ✓ ok
const regexp = /test value/     // ✓ ok

no-return-assign

"no-return-assign": ["error", "except-parens"]

规定return 语句中的赋值必需有括号包裹。代码示例如下：

function sum (a, b) {
  return result = a + b     // ✗ avoid
}

function sum (a, b) {
  return (result = a + b)   // ✓ ok
}

no-sequences

"no-sequences": "error"

规定避免使用逗号操作符。代码示例如下：

if (doSomething(), !!test) {}   // ✗ avoid

no-undef-init

"no-undef-init": "error"

规定不要使用 undefined 来初始化变量。代码示例如下：

let name = undefined    // ✗ avoid

let name
name = 'value'          // ✓ ok

no-unneeded-ternary

"no-unneeded-ternary": ["error", { "defaultAssignment": false }]

规定如果有更好的实现，尽量不要使用三元表达式。代码示例如下：

let score = val ? val : 0     // ✗ avoid
let score = val || 0          // ✓ ok

no-unsafe-negation

"no-unsafe-negation": "error"

规定关系运算符的左值不要做取反操作。代码示例如下：

if (!key in obj) {}       // ✗ avoid

no-unused-vars

"no-unused-vars": ["error", { "vars": "all", "args": "none", "ignoreRestSiblings": true }]

规定不要定义未使用的变量。代码示例如下：

function myFunction () {
  var result = something()   // ✗ avoid
}

no-useless-call

"no-useless-call": "error"

规定避免不必要的 .call() 和 .apply()。代码示例如下：

sum.call(null, 1, 2, 3)   // ✗ avoid

no-useless-computed-key

"no-useless-computed-key": "error"

规定避免使用不必要的计算值作对象属性。代码示例如下：

const user = { ['name']: 'John Doe' }   // ✗ avoid
const user = { name: 'John Doe' }       // ✓ ok

no-useless-constructor

"no-useless-constructor": "error"

规定禁止多余的构造器(ES2015会自动生成一个简单构造器)。代码示例如下：

class Car {
  constructor () {      // ✗ avoid
  }
}

no-useless-escape

"no-useless-escape": "error"

规定禁止不必要的转义。代码示例如下：

let message = 'Hell\o'  // ✗ avoid

no-useless-rename

"no-useless-rename": "error"

规定import, export 和解构操作中，禁止赋值到同名变量。代码示例如下：

import { config as config } from './config'     // ✗ avoid
import { config } from './config'               // ✓ ok

no-with

"no-with": "error"

规定禁止使用 with。代码示例如下：

with (val) {...}    // ✗ avoid

one-var

"one-var": ["error", { "initialized": "never" }]

规定每个 var 关键字单独声明一个变量。代码示例如下：

// ✓ ok
var silent = true
var verbose = true

// ✗ avoid
var silent = true, verbose = true

// ✗ avoid
var silent = true,
    verbose = true

quotes

"quotes": ["error", "single", { "avoidEscape": true, "allowTemplateLiterals": true }]

规定除需要转义的情况外，字符串统一使用单引号。第二个参数取值“single”、“double”，分别表示单引号和双引号。第三个参数配置是否允许嵌套和是否允许字符串模板。代码示例如下：

console.log('hello there')
$("")

semi

"semi": ["error", "always"]

规定必须添加分号。第二个参数配置开关取值“never”、“always”。代码示例如下：

window.alert('hi')   // ✓ ok
window.alert('hi');  // ✗ avoid

use-isnan

"use-isnan": "error"

规定检查 NaN 的正确姿势是使用 isNaN()。

wrap-iife

"wrap-iife": ["error", "any", { "functionPrototypeMethods": true }]

规定自调用匿名函数 (IIFEs) 使用括号包裹。代码示例如下：

const getName = function () { }()     // ✗ avoid

const getName = (function () { }())   // ✓ ok
const getName = (function () { })()   // ✓ ok

arrow-spacing

"arrow-spacing": ["error", { "before": true, "after": true }]

规定箭头函数必须有前后括号。

命名

new-cap

"new-cap": ["error", { "newIsCap": true, "capIsNew": false }]

规定构造函数要以大写字母开头。第二个参数配置细则，"newIsCap"配置只要是new关键字初始化的函数，首字母必须大写；“capIsNew”配置是否允许大写字母开头的函数不使用new关键字初始化。代码示例如下：

function animal () {}
var dog = new animal()    // ✗ avoid

function Animal () {}
var dog = new Animal()    // ✓ ok

function Animal () {}
var dog = Animal()    // ✓ ok

camelcase

"camelcase": ["error", { "properties": "never" }]

规定变量和函数使用驼峰命名法。第二个参数配置对象属性是否也要遵循驼峰命名法。示例代码如下：

  function my_function () { }    // ✗ avoid
  function myFunction () { }     // ✓ ok

  var my_var = 'hello'           // ✗ avoid
  var myVar = 'hello'            // ✓ ok

Angular规则

angular/no-private-call

"angular/no-private-call":["error"]

规定使用直接使用angular中带$$符号的成员，他们都是私有成员。

angular/di-unused

"angular/di-unused":["error"]

规定不要注入不使用的服务。

angular/empty-controller

"angular/empty-controller":["error"]

规定控制器不能为空。

angular/no-run-logic

"angular/no-run-logic":["error"]

规定控制器中只有调用代码，没有声明逻辑。

angular/no-cookiestore

"angular/no-cookiestore":["error"]

规定取代$cookiesStore，而使用$cookie来操作缓存。

angular/no-directive-replace

"angular/no-directive-replace":["error"]

规定自定义指令中不能使用replace属性。

angular/no-http-callback

"angular/no-http-callback":["error"]

规定不要直接使用 $http 的回调函数，应该使用promise来操作回调。

angular/controller-name

"angular/controller-name":["error","/[a-z].*Ctrl/"]

规定控制器命名规则，以小写字母开头以“Ctrl”结尾。

angular/di

"angular/di":["error","array"]

规定依赖注入规则，必须有数组列表并且参数与之一致。

angular/function-type

"angular/function-type":["error","anonymous"]

规定为angular组件指定一致的函数风格——匿名函数。

angular/document-service

"angular/document-service":["off"]

规定使用$document。

angular/interval-service

"angular/interval-service":["off"]

规定使用$interval。

angular/log

"angular/log":["off"]

规定使用$log。

angular/timeout-service

"angular/timeout-service":["off"]

规定使用$timeout。

angular/window-service

"angular/window-service":["off"]

规定使用$window。

参考文章：

https://github.com/standard/standard/blob/master/docs/RULES-zhcn.md#javascript-standard-style

http://eslint.cn/

欢迎关注我的微信公众号：

Eslint规则字典

Eslint(二)：规则字典

代码格式

indent

block-spacing

brace-style

comma-spacing

curly

dot-location

eol-last

func-call-spacing

key-spacing

no-mixed-spaces-and-tabs

no-multi-spaces

no-multiple-empty-lines

no-trailing-spaces

no-whitespace-before-property

object-property-newline

operator-linebreak

padded-blocks

rest-spread-spacing

semi-spacing

space-before-blocks

space-before-function-paren

space-in-parens

space-infix-ops

space-unary-ops

template-curly-spacing

yield-star-spacing

generator-star-spacing

可能出错代码

accessor-pairs

comma-dangle

comma-style

constructor-super

eqeqeq

handle-callback-err

new-parens

no-array-constructor

no-class-assign

no-const-assign

no-constant-condition

no-delete-var

no-dupe-args

no-dupe-class-members

no-dupe-keys

no-duplicate-case

no-empty-character-class

no-empty-pattern

no-ex-assign

no-fallthrough

no-func-assign

no-global-assign

no-invalid-regexp

no-iterator

no-self-assign

no-self-compare

no-shadow-restricted-names

no-sparse-arrays

no-template-curly-in-string

no-throw-literal

no-unexpected-multiline

no-unmodified-loop-condition

no-unreachable

no-unsafe-finally

valid-typeof

no-control-regex

no-unused-expressions

no-use-before-define

最佳实践

accessor-pairs

no-caller

no-cond-assign

no-debugger

no-eval

no-extend-native

no-extra-bind

no-extra-boolean-cast

no-extra-parens

no-floating-decimal