style.md

Style

Array bracket spacing

enforce spacing inside array brackets

✓ Enabled (error)

Block spacing

enforce spacing inside single-line blocks

✓ Enabled (error)

Brace style

enforce one true brace style

✓ Enabled (error)

Camelcase

require camel case names

✓ Enabled (error)

Comma spacing

enforce spacing before and after comma

✓ Enabled (error)

Comma style

enforce one true comma style

✓ Enabled (error)

Computed property spacing

disallow padding inside computed properties

✓ Enabled (error)

Consistent this

enforces consistent naming when capturing the current execution context

✓ Enabled (error)

// Bad
/*
const self = this;
*/
// Good
const _this = this;

Eol last

enforce newline at the end of file, with no multiple empty lines

✓ Enabled (error)

Func names

require function expressions to have a name

✖ Disabled

Func style

enforces use of function declarations or expressions

✖ Disabled

Id blacklist

Blacklist certain identifiers to prevent them being used

✖ Disabled

// Bad
/*
function _test(data) {}
*/

// Good
function _test(productData) {}

Id length

this option enforces minimum and maximum identifier lengths (variable names, property names etc.)

✖ Disabled

Id match

require identifiers to match the provided regular expression

✖ Disabled

Indent

this option sets a specific tab width for your code

✓ Enabled (warning)

Jsx quotes

specify whether double or single quotes should be used in JSX attributes

✓ Enabled (error)

Key spacing

enforces spacing between keys and values in object literal properties

✓ Enabled (error)

Keyword spacing

require a space before & after certain keywords

✓ Enabled (error)

Linebreak style

disallow mixed 'LF' and 'CRLF' as linebreaks

✖ Disabled

Lines around comment

enforces empty lines around comments

✖ Disabled

Max depth

specify the maximum depth that blocks can be nested

✓ Enabled (error)

Max len

specify the maximum length of a line in your program

✓ Enabled (error)

Max nested callbacks

specify the maximum depth callbacks can be nested

✓ Enabled (error)

Max params

limits the number of parameters that can be used in the function declaration.

✓ Enabled (error)

Max statements per line

restrict the number of statements per line

✓ Enabled (error)

Max statements

specify the maximum number of statement allowed in a function

✖ Disabled

New cap

require a capital letter for constructors

✓ Enabled (error)

New parens

disallow the omission of parentheses when invoking a constructor with no arguments

✓ Enabled (error)

Newline after var

allow/disallow an empty newline after var statement

✖ Disabled

Newline before return

require an empty line before return statements

✖ Disabled

Newline per chained call

enforces new line after each method call in the chain to make it more readable and easy to maintain

✓ Enabled (error)

No array constructor

disallow use of the Array constructor

✓ Enabled (error)

No bitwise

disallow use of bitwise operators

✓ Enabled (error)

No continue

disallow use of the continue statement

✓ Enabled (error)

No inline comments

disallow comments inline after code

✖ Disabled

No lonely if

disallow if as the only statement in an else block

✓ Enabled (error)

No mixed spaces and tabs

disallow mixed spaces and tabs for indentation

✓ Enabled (error)

No multiple empty lines

disallow multiple empty lines and only one newline at the end

✓ Enabled (error)

No negated condition

disallow negated conditions

✖ Disabled

No nested ternary

disallow nested ternary expressions

✓ Enabled (error)

No new object

disallow use of the Object constructor

✓ Enabled (error)

No plusplus

disallow use of unary operators, ++ and --

✖ Disabled

No restricted syntax

disallow certain syntax forms

No spaced func

disallow space between function identifier and application

✓ Enabled (error)

No ternary

disallow the use of ternary operators

✖ Disabled

No trailing spaces

disallow trailing whitespace at the end of lines

✓ Enabled (error)

No underscore dangle

allow dangling underscores in identifiers

✖ Disabled

No unneeded ternary

disallow the use of Boolean literals in conditional expressions also, prefer a || b over a ? a : b

✓ Enabled (error)

No whitespace before property

disallow whitespace before properties

✓ Enabled (error)

Object curly spacing

require padding inside curly braces

✓ Enabled (error)

Object property newline

enforce "same line" or "multiple line" on object properties.

✖ Disabled

One var declaration per line

require a newline around variable declaration

✓ Enabled (error)

// Bad
/*
function bad() {
	const d = 1, e = 2;
}
*/

// Good
function good() {
	let a, b, c;
	const d = 1;
	const e = 2;
}

One var

allow just one var statement per function

✓ Enabled (error)

// Bad
/*
function bad() {
	const a = 1,
		b = 2,
		c = 3;
}
*/

// Good
function good() {
	const d = 4;
	const e = 5;
	const f = 6;
}

Operator assignment

require assignment operator shorthand where possible or prohibit it entirely

✖ Disabled

Operator linebreak

enforce operators to be placed before or after line breaks

✖ Disabled

Padded blocks

enforce padding within blocks

✖ Disabled

Quote props

require quotes around object literal property names

✓ Enabled (error)

Quotes

specify whether double or single quotes should be used

✓ Enabled (error)

Require jsdoc

do not require jsdoc

✓ Enabled (error)

Semi spacing

enforce spacing before and after semicolons

✓ Enabled (error)

Semi

require or disallow use of semicolons instead of ASI

✓ Enabled (error)

Sort vars

sort variables within the same declaration block

✖ Disabled

Space before blocks

require or disallow space before blocks

✓ Enabled (error)

// Bad
/*
if (a){
	b();
}

function a(){}

for (;;) {
	b();
}

try {} catch (a){}

class Foo{
	constructor(){}
}
*/

// Good
if (a) {
	b();
}

function a() {}

for (;;) {
	b();
}

try {} catch (a) {}

class Foo {
	constructor() {}
}

Space before function paren

require or disallow space before function opening parenthesis

✓ Enabled (error)

// Bad
/*
function foo () {
	// ...
}

var bar = function() {
	// ...
};

class Foo {
	constructor () {
		// ...
	}
}

var foo = {
	bar () {
		// ...
	}
};
*/

// Good
function foo() {
	// ...
}

var bar = function () {
	// ...
};

class Foo {
	constructor() {
		// ...
	}
}

var foo = {
	bar() {
		// ...
	},
};

Space in parens

require or disallow spaces inside parentheses

✓ Enabled (error)

// Bad
/*
foo( 'bar' );
var x = ( 1 + 2 ) * 3;
*/

// Good
foo('bar');
var x = (1 + 2) * 3;

Space infix ops

require spaces around operators

✓ Enabled (error)

// Bad
/*
var sum = 1+2;
*/
var sum = 1 + 2;

Space unary ops

Require or disallow spaces before/after unary operators

✖ Disabled

Spaced comment

require or disallow a space immediately following the // or /* in a comment

✓ Enabled (error)

Unicode bom

require or disallow the Unicode Byte Order Mark

✖ Disabled

Wrap regex

require regex literals to be wrapped in parentheses

✓ Enabled (error)

// Bad
/*
function a() {
	return /foo/.test('bar');
}
*/

// Good
function a() {
	return (/foo/).test('bar');
}