block-scoped-var:#:Treat var as Block Scoped:#: The block-scoped-var rule generates warnings when variables are used outside of the block in which they were defined. This emulates C-style block scope.  
brace-style:#:Require Brace Style:#: Brace style is closely related to [indent style](http://en.wikipedia.org/wiki/Indent_style) in programming and describes the placement of curly braces relative to their control statement and body. There are probably a dozen, if not more, brace styles in the world.  The *one true brace style* is one of the most common brace styles in JavaScript, in which the opening curly brace of a block is placed on the same line as its corresponding statement or declaration.  
camelcase:#:Require Camelcase:#: When it comes to naming variables, styleguides generally fall into one of two camps: camelcased (variableName) and underscores(variable_name). This rule focuses on using the camelcase approach. If your styleguide calls for camelcasing your variable names, then this rule is for you!  
comma-dangle:#:Disallow or Enforce Dangling Commas:#: Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec, however IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.  
comma-spacing:#:Enforces spacing around commas:#: Spacing around commas improve readability of a list of items. Although most of the style guidelines for languages prescribe adding a space after a comma and not before it, it is subjective to the preferences of a project.  
comma-style:#:Comma style:#: Comma Style rule enforces comma styles for a list of things separated by commas. There are two comma styles primarily in javascript. The standard one in which commas are placed at the end of the line. And Comma-First, in which, commas are placed at the start of the next line after the list item.  One of the justifications for using Comma-First is that it helps tracking missing and trailing commas. In case linting is turned off, missing commas in variable declarations lead to leakage of global variables and trailing commas lead to errors in older versions of IE.   
complexity:#:Limit Cyclomatic Complexity:#: Cyclomatic complexity measures the number of linearly independent paths through a program's source code. This rule allows setting a cyclomatic complexity threshold.  
consistent-return:#:Require Consistent Returns:#: One of the confusing aspects of JavaScript is that any function may or may not return a value at any point in time. When a function exits without any return statement executing, the function returns undefined. Similarly, calling return without specifying any value will cause the function to return undefined. Only when return is called with a value is there a change in the function's return value.  Unlike statically-typed languages that will catch when a function doesn't return the type of data expected, JavaScript has no such checks, meaning that it's easy to make mistakes such as this.  
consistent-this:#:Require Consistent This:#: It is often necessary to capture the current execution context in order to make it available subsequently.  
curly:#:Require Following Curly Brace Conventions:#: JavaScript allows the omission of curly braces when a block contains only one statement.  
default-case:#:Require Default Case in Switch Statements:#: Some code conventions require that all switch statements have a default case, even if the default case is empty.  
dot-notation:#:Require Dot Notation:#: In JavaScript, one can access properties using the dot notation (foo.bar) or square-bracket notation (foo["bar"]). However, the dot notation is often preferred because it is easier to read, less verbose, and works better with aggressive JavaScript minimizers.  
eol-last:#:Require file to end with single newline:#: Trailing newlines in non-empty files are a common UNIX idiom. Benefits of trailing newlines include the ability to concatenate or append to files as well as output files to the terminal without interfering with shell prompts. This rule enforces newlines for all non-empty programs.  Prior to v0.16.0 this rule also enforced that there was only a single line at the end of the file. If you still want this behaviour, consider enabling [no-multiple-empty-lines](no-multiple-empty-lines.md) and/or [no-trailing-spaces](no-trailing-spaces.md).  
eqeqeq:#:Require === and !==:#: It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.  The reason for this is that == and != do type coercion which follows the rather obscure [Abstract Equality Comparison Algorithm](http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3). For instance, the following statements are all considered true.  - [] == false - [] == ![] - 3 == "03"  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.  
func-names:#:Require Function Expressions to have a Name:#: A pattern that's becoming more common is to give function expressions names to aid in debugging.  
func-style:#:Enforce Function Style:#: There are two ways of defining functions in JavaScript: function declarations and function expressions.  
generator-star:#:Enforce the position of the * in generators:#: **Deprecation notice**: This rule is deprecated and has been superseded by the [generator-star-spacing](generator-star-spacing.md) rule. It will be removed in ESLint v1.0.  Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.  Here is an example of a generator function.  
generator-star-spacing:#:Enforce the spacing around the * in generators:#: Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.  Here is an example of a generator function.  
global-strict:#:Global Strict Mode:#: **Deprecation notice**: This rule is deprecated and has been superseded by the [strict](strict.md) rule. It will be removed in ESLint v1.0. "global" mode in the strict rule is most similar to this rule.  Strict mode is enabled by using the following pragma in your code.  
guard-for-in:#:Require Guarding for-in:#: Looping over objects with a for in loop will include properties that are inherited through the prototype chain. This behavior can lead to unexpected items in your for loop.  
handle-callback-err:#:Ensures Callback Error Handling:#: In node, a common pattern for dealing with asynchronous behavior is called the callback pattern. This pattern expects as the first argument of the callback an Error object, which may be null. Forgetting to handle these errors can lead to some really strange behavior in your application.  
indent:#:Validate Indentation:#: This option validates a specific tab width for your code in block statements.  There are several common guidelines, which indentation your code should have in nested blocks and statements, like.  
key-spacing:#:Enforce Property Spacing:#: Enforces spacing around the colon in object literal properties. It can verify each property individually, or it can ensure vertical alignment of groups of properties in an object literal.  
max-depth:#:Limit Maximum Depth:#: The max-depth rule allows you to specify the maximum depth blocks can be nested.  
max-len:#:Limit Maximum Length of Line:#: Very long lines of code in any language can be difficult to read. In order to aid in readability and maintainability many coders have developed a convention to limit lines of code to X number of characters (traditionally 80 characters).  
max-nested-callbacks:#:Set Maximum Depth of Nested Callbacks:#: Many JavaScript libraries use the callback pattern to manage asynchronous operations. A program of any complexity will most likely need to manage several asynchronous operations at various levels of concurrency. A common pitfall that is easy to fall into is nesting callbacks, which makes code more difficult to read the deeper the callbacks are nested.  
max-params:#:Limit Maximum Number of Parameters:#: Functions that take numerous parameters can be difficult to read and write because it requires the memorization of what each parameter is, its type, and the order they should appear in. As a result, many coders adhere to a convention that caps the number of parameters a function can take.  
max-statements:#:Limit Maximum Number of Statements:#: The max-statements rule allows you to specify the maximum number statements allow in a function.  
new-cap:#:Require Constructors to Use Initial Caps:#: The new operator in JavaScript creates a new instance of a particular type of object. That type of object is represented by a constructor function. Since constructor functions are just regular functions, the only defining characteristic is that new is being used as part of the call. Native JavaScript functions begin with an uppercase letter to distinguish those functions that are to be used as constructors from functions that are not. Many style guides recommend following this pattern to more easily determine which functions are to be used as constructors.  
new-parens:#:Require Parens for Constructors:#: JavaScript allows the omission of parentheses when invoking a function via the new keyword and the constructor has no arguments. However, some coders believe that omitting the parentheses is inconsistent with the rest of the language and thus makes code less clear.  
no-alert:#:Disallow Use of Alert:#: JavaScripts' alert, confirm, and prompt functions are widely considered to be obtrusive as UI elements and should be replaced by a more appropriate custom UI implementation. Furthermore, alert is often used while debugging code, which should be removed before deployment to production.  
no-array-constructor:#:Disallow creation of dense arrays using the `Array` constructor:#: Use of the Array constructor to construct a new array is generally discouraged in favour of array literal notation because of the single-argument pitfall and because the Array global may be redefined. The exception is when the Array constructor is used to intentionally create sparse arrays of a specified size by giving the constructor a single numeric argument.  
no-bitwise:#:Disallow Bitwise Operators:#: The use of bitwise operators in JavaScript is very rare and often & or | is simply a mistyped && or ||, which will lead to unexpected behavior.  
no-caller:#:Disallow Use of caller/callee:#: The use of arguments.caller and arguments.callee make several code optimizations impossible. They have been deprecated in future versions of JavaScript and their use is forbidden in ECMAScript 5 while in strict mode.  
no-catch-shadow:#:Disallow Shadowing of Variables Inside of catch:#: In IE 8 and earlier, the catch clause parameter can overwrite the value of a variable in the outer scope, if that variable has the same name as the catch clause parameter.  
no-comma-dangle:#:Disallow Dangling Commas:#: **Deprecation notice**: This rule is deprecated and has been superseded by the [comma-dangle](comma-dangle.md) rule. It will be removed in ESLint v1.0.  Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec, however IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.  
no-cond-assign:#:Disallow Assignment in Conditional Statements:#: In conditional statements, it is very easy to mistype a comparison operator (such as ==) as an assignment operator (such as =).  
no-console:#:Disallow Use of console:#: In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.  
no-constant-condition:#:Disallow use of constant expressions in conditions:#: Comparing a literal expression in a condition is usually a typo or development trigger for a specific behavior.  
no-control-regex:#:Disallow Controls Characters in Regular Expressions:#: Control characters are special, invisible characters in the ASCII range 0-31. These characters are rarely used in JavaScript strings so a regular expression containing these characters is most likely a mistake.  
no-debugger:#:Disallow debugger:#: The debugger statement is used to tell the executing JavaScript environment to stop execution and start up a debugger at the current point in the code. This has fallen out of favor as a good practice with the advent of modern debugging and development tools. Production code should definitely not contain debugger, as it will cause the browser to stop executing code and open an appropriate debugger.  
no-delete-var:#:Disallow Variables Deletion:#: This rule prevents the use of delete operator on variables.  
no-div-regex:#:Disallow Regexs That Look Like Division:#: Require regex literals to escape division operators.  
no-dupe-args:#:No duplicate arguments:#: In strict mode you will receive a SyntaxError if a function takes multiple arguments with the same name. Outside of strict mode duplicate arguments will mask the value of the first argument. This rule checks for duplicate parameter names to help prevent that mistake.  
no-dupe-keys:#:Disallow Duplicate Keys:#: Creating objects with duplicate keys in objects can cause unexpected behavior in your application. The no-dupe-keys rule flags the use of duplicate keys in object literals.  
no-duplicate-case:#:Rule to disallow a duplicate case label:#: A switch statements with duplicate case labels is normally an indication of a programmer error.  In the following example the 3rd case label uses again the literal 1 that has already been used in the first case label. Most likely the case block was copied from above and it was forgotten to change the literal.  
no-else-return:#:Disallow return in else:#: If an if block contains a return statement, the else block becomes unnecessary. Its contents can be placed outside of the block.  
no-empty-class:#:Disallow Empty Character Classes:#: Empty character classes in regular expressions do not match anything and can result in code that may not work as intended.  
no-empty-label:#:No empty labels:#: Labeled statements are only used in conjunction with labeled break and continue statements. ECMAScript has no goto statement.   
no-empty:#:Disallow Empty Block Statements:#: Empty statements usually occur due to refactoring that wasn't completed.  
no-eq-null:#:Disallow Null Comparisons:#: Comparing to null without a type-checking operator (== or !=), can have unintended results as the comparison will evaluate to true when comparing to not just a null, but also an undefined value.  
no-eval:#:Disallow eval:#: JavaScript's eval() function is potentially dangerous and is often misused. Using eval() on untrusted code can open a program up to several different injection attacks. The use of eval() in most contexts can be substituted for a better, alternative approach to a problem.  
no-ex-assign:#:Disallow Assignment of the Exception Parameter:#: When an error is caught using a catch block, it's possible to accidentally (or purposely) overwrite the reference to the error.  
no-extend-native:#:Disallow Extending of Native Objects:#: In JavaScript, you can extend any object, including builtin or "native" objects. Sometimes people change the behavior of these native objects in ways that break the assumptions made about them in other parts of the code.  For example here we are overriding a builtin method that will then affect all Objects, even other builtins.  
no-extra-bind:#:Disallow unnecessary function binding:#: Function binding makes no difference in function expressions, when the function does not use this.  
no-extra-boolean-cast:#:Disallow Extra Boolean Casts:#: In contexts such as an if statement's test where the result of the expression will already be coerced to a Boolean, casting to a Boolean via double negation (!!) is unnecessary.  
no-extra-parens:#:Disallow Extra Parens:#: This rule restricts the use of parentheses to only where they are necessary.  
no-extra-semi:#:Disallow Extra Semicolons:#: JavaScript will more or less let you put semicolons after any statement without complaining. Typos and misunderstandings about where semicolons are required can lead to extra semicolons that are unnecessary.   
no-extra-strict:#:Disallow Unnecessary Strict Pragma:#: **Deprecation notice**: This rule is deprecated and has been superseded by the [strict](strict.md) rule. It will be removed in ESLint v1.0. Both "global" and "function" mode in the strict rule implement this rule's behavior.  The "use strict"; directive applies to the scope in which it appears and all inner scopes contained within that scope. Therefore, using the "use strict"; directive in one of these inner scopes is unnecessary.  
no-fallthrough:#:Disallow Case Statement Fallthrough:#: The switch statement in JavaScript is one of the more error-prone constructs of the language thanks in part to the ability to "fall through" from one case to the next.  
no-floating-decimal:#:Disallow Floating Decimals:#: Float values in JavaScript contain a decimal point, and there is no requirement that the decimal point be preceded or followed by a number.  
no-func-assign:#:Disallow Function Assignment:#: JavaScript functions can be written as a FunctionDeclaration function foo() { ... } or as a FunctionExpression var foo = function() { ... };. While a JavaScript interpreter might tolerate it, overwriting/reassigning a function written as a FunctionDeclaration is often indicative of a mistake or issue.  
no-implied-eval:#:Disallow Implied eval:#: It's considered a good practice to avoid using eval() in JavaScript. There are security and performance implications involved with doing so, which is why many linters (including ESLint) disallow eval() by default. However, there are some other ways to pass a string and have it interpreted as JavaScript code that have similar concerns.  The first is using setTimeout() or setInterval(), both of which can accept a string of JavaScript code as their first argument.  
no-inline-comments:#:Disallows comments after code. Comments must come on their own lines:#: Some style guides disallow a comments on the same line as code. If there are comments immediately following code, it can make it harder to read the code. On the other hand, it is sometimes faster and more obvious to put comments immediately following code.   
no-inner-declarations:#:Declarations in Program or Function Body:#: In JavaScript, prior to ES6, a function declaration is only allowed in the first level of a program or the body of another function, though parsers sometimes [erroneously accept them elsewhere](https://code.google.com/p/esprima/issues/detail?id=422). This only applies to function declarations; named or anonymous function expressions can occur anywhere an expression is permitted.  
no-invalid-regexp:#:Disallow Invalid Regular Expressions:#: This rule validates string arguments passed to the RegExp constructor.  
no-irregular-whitespace:#:No irregular whitespace:#: Invalid or irregular whitespace causes issues with ECMAScript 5 parsers and also makes code harder to debug in a similar nature to mixed tabs and spaces.  Various whitespace characters can be inputted by programmers by mistake for example from copying or keyboard shortcuts. Pressing Alt + Space on OS X adds in a non breaking space character for example.  Known issues these spaces cause.  -  Zero Width Space -  Is NOT considered a separator for tokens and is often parsed as an Unexpected token ILLEGAL -  Is NOT shown in modern browsers making code repository software expected to resolve the visualisation -  Line Separator -  Is NOT a valid character within JSON which would cause parse errors  
no-iterator:#:Disallow Iterator:#: The __iterator__ property can used to create custom iterators that are compatible with JavaScript's for in and for each constructs. However, this property is not supported in many browsers, so it should be used with caution.  
no-labels:#:Disallow Labeled Statements:#: Labeled statements in JavaScript are used in conjunction with break and continue to control flow around multiple loops.  
no-label-var:#:Disallow Labels That Are Variables Names:#: 
no-lone-blocks:#:Disallow Unnecessary Nested Blocks:#: In JavaScript, standalone code blocks delimited by curly braces do not create a new scope and have no use.  
no-lonely-if:#:Disallow if as the Only Statement in an else Block:#: If an if statement is the only statement in the else block of a parent if statement, it is often clearer to combine the two to using else if form.  
no-loop-func:#:Disallow Functions in Loops:#: Writing functions within loops tends to result in errors due to the way the function creates a closure around the loop.  
no-mixed-requires:#:Disallow Mixed Requires:#: In the Node.JS community it is often customary to separate the required modules from other variable declarations, sometimes also grouping them by their type. This rule helps you enforce this convention.  
no-mixed-spaces-and-tabs:#:Disallow mixed spaces and tabs for indentation:#: Most code conventions require either tabs or spaces be used for indentation. As such, it's usually an error if a single line of code is indented with both tabs and spaces.  
no-multiple-empty-lines:#:Disallows multiple blank lines:#: Some developers prefer to have multiple blank lines removed, while others feel that it helps improve readability. Whitespace is useful for separating logical sections of code, but excess whitespace takes up more of the screen.   
no-multi-spaces:#:Disallow multiple spaces:#: It's a good practice to add whitespace in expressions to enhance readability of code such as.  
no-multi-str:#:Disallow Multiline Strings:#: It's possible to create multiline strings in JavaScript by using a slash before a newline.  
no-native-reassign:#:Disallow Reassignment of Native Objects:#: Reports an error when they encounter an attempt to assign a value to built-in native object.  
no-negated-in-lhs:#:Disallow negated left operand of `in` operator:#: 
no-nested-ternary:#:Disallow Nested Ternaries:#: Nesting ternary expressions makes code unclear. The no-nested-ternary rule disallows the use of nested ternary expressions.  
no-new-func:#:Disallow Function Constructor:#: It's possible to create functions in JavaScript using the Function constructor.  
no-new:#:Disallow new For Side Effects:#: The goal of using new with a constructor is typically to create an object of a particular type and store that object in a variable.  
no-new-object:#:Disallow new Object:#: The Object constructor is used to create new generic objects in JavaScript.  
no-new-require:#:Disallow new require:#: The require function is used to include modules that exist in separate files.  
no-new-wrappers:#:Disallow Primitive Wrapper Instances:#: There are three primitive types in JavaScript that have wrapper objects: string, number, and boolean.  
no-obj-calls:#:Disallow Global Object Function Calls:#: ECMAScript provides several global objects that are intended to be used as-is. Some of these objects look as if they could be constructors due their capitalization (such as Math and JSON) but will throw an error if you try to execute them as functions.  The [ECMAScript 5 specification](http://es5.github.io/#x15.8) makes it clear that both Math and JSON cannot be invoked.  > The Math object does not have a [[Call]] internal property; it is not possible to invoke the Math object as a function.  
no-octal-escape:#:Disallow Octal Escapes:#: As of version 5 of the ECMAScript specification, octal escape sequences are a deprecated feature and should not be used. It is recommended that Unicode escapes be used instead.  
no-octal:#:Disallow Octal Literals:#: Octal literals are numerals that begin with a leading zero.  
no-path-concat:#:Disallow string concatenation when using __dirname and __filename:#: In Node.js, the __dirname and __filename global variables contain the directory path and the file path of the currently executing script file, respectively.  
no-plusplus:#:Disallow ++ and --:#: The no-plusplus rule flags the use of unary operators, ++ and --.  
no-process-env:#:Disallow process.env:#: The process.env object in Node.js is used to store deployment/configuration parameters. Littering it through out a project could lead to maintenance issues as it's another kind of global dependency. As such, it could lead to merge conflicts in a multi-user setup and deployment issues in a multi-server setup. Instead, one of the best practices is to define all those parameters in a single configuration/settings file which could be accessed throughout the project.   
no-process-exit:#:Disallow process.exit:#: The process.exit() method in Node.js is used to immediately stop the Node.js process and exit.  
no-proto:#:Disallow Use of __proto__:#: __proto__ property has been deprecated as of ECMAScript 3.1 and shouldn't be used in the code. Use getPrototypeOf method instead.  
no-redeclare:#:Disallow Redeclaring Variables:#: In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.  
no-regex-spaces:#:Disallow Spaces in Regular Expressions:#: Regular expressions can be very complex and difficult to understand, which is why it's important to keep them as simple as possible in order to avoid mistakes.  
no-reserved-keys:#:Disallow Use of Reserved Words as Keys:#: ECMAScript 3 described as series of keywords and reserved words if and public, that are used or intended to be used for a core language feature.  
no-restricted-modules:#:Disallow Node modules:#: Disallowing usage of specific node modules can be useful if you want to control the available methods, a developer can use, to implement a feature.  This way you can block usage of the fs module if you want disallow file system access. Blocking the os module can be useful if you don't want to allow any operating system specific code.  
no-return-assign:#:Disallow Assignment in return Statement:#: One of the interesting, and sometimes confusing, aspects of JavaScript is that assignment can happen at almost any point.  
no-script-url:#:Disallow Script URLs:#: Using javascript: urls is considered by some as a form of eval. Script passed after javascript: has to be parsed and evaluated by the browser the same way that it does eval.  
no-self-compare:#:Disallow Self Compare:#: Comparing a variable against itself is usually an error, either an typo or refactoring error. It is confusing to the reader and may potentially introduce a runtime error.  The only time you would compare a variable against itself is when you are testing for NaN. However, it is far more appropriate to use the isNaN() function for that use case rather than leaving the reader of the code to determine the intent of self comparison.  
no-sequences:#:Disallow Use of Comma Operator:#: The comma operator includes multiple expressions where only one is expected.  
no-shadow:#:Disallow Shadowing:#: Shadowing is the process by which a local variable shares the same name as a variable in its containing scope.  
no-shadow-restricted-names:#:Disallow Shadowing of Restricted Names:#: ES5 §15.1.1 Value Properties of the Global Object (NaN, Infinity, undefined) as well as strict mode restricted identifiers eval and arguments are considered to be restricted names in JavaScript.  
no-space-before-semi:#:Disallow Spaces Before Semicolon:#: **Deprecation notice**: This rule is deprecated and has been superseded by the [semi-spacing](semi-spacing.md) rule. It will be removed in ESLint v1.0.  JavaScript allows for placing unnecessary spaces between an expression and the closing semicolon.  Space issues can also cause code to look inconsistent and harder to read.  
no-spaced-func:#:Disallow Spaces in Function Calls:#: While it's possible to have whitespace between the name of a function and the parentheses that execute it, such patterns tend to look more like errors.  
no-sparse-arrays:#:Disallow Sparse Arrays:#: Sparse arrays contain empty slots, most frequently due to multiple commas being used in an array literal.  
no-sync:#:Disallow Synchronous Methods:#: In Node.js, most I/O is done through asynchronous methods. However, there are often synchronous versions of the asynchronous methods. For example, fs.exists() and fs.existsSync(). In some contexts, using synchronous operations is okay (if, as with ESLint, you are writing a command line utility). However, in other contexts the use of synchronous operations is considered a bad practice that should be avoided. For example, if you are running a high-travel web server on Node.js, you should consider carefully if you want to allow any synchronous operations that could lock up the server.  
no-ternary:#:Disallow Ternary Operators:#: The ternary operator is used to conditionally assign a value to a variable. Some believe that the use of ternary operators leads to unclear code.  
no-throw-literal:#:Restrict what can be thrown as an exception:#: It is considered good practice to only throw the Errorobject itself or an object using the Error object as base objects for user-defined exceptions. The fundamental benefit of Error objects is that they automatically keep track of where they were built and originated. This rule restrict what can be thrown as an exception by preventing to throw literals.  
no-trailing-spaces:#:Disallow trailing spaces at the end of lines:#: Sometimes in the course of editing files, you can end up with extra whitespace at the end of lines. These whitespace differences can be picked up by source control systems and flagged as diffs, causing frustration for developers. While this extra whitespace causes no functional issues, many code conventions require that trailing spaces be removed before checkin.  
no-undefined:#:Disallow Use of `undefined` Variable:#: The undefined variable is unique in JavaScript because it is actually a property of the global object.  
no-undef-init:#:Disallow Initializing to undefined:#: In JavaScript, a variable that is declared and not initialized to any value automatically gets the value of undefined.  
no-undef:#:Disallow Undeclared Variables:#: Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment. This rule provides compatibility with [JSHint](http://www.jshint.com)'s and [JSLint](http://www.jslint.com)'s treatment of global variables.  This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).  
no-underscore-dangle:#:Disallow Dangling Underscores in Identifiers:#: As far as naming conventions for identifiers go, dangling underscores may be the most polarizing in JavaScript.  
no-unreachable:#:Disallow Unreachable Code:#: A number of statements unconditionally exit a block of code. Any statements after that will not be executed and may be an error. The presence of unreachable code is usually a sign of a coding error.  
no-unused-expressions:#:Disallow Unused Expressions:#: Unused expressions are those expressions that evaluate to a value but are never used.  
no-unused-vars:#:Disallow Unused Variables:#: Variables that are declared and not used anywhere in the code are most likely an error due to incomplete refactoring. Such variables take up space in the code and can lead to confusion by readers.  
no-use-before-define:#:Disallow Early Use:#: Since variable and function declarations are hoisted to the top of a scope, it's possible to use identifiers before their formal declarations in code. This can be confusing and some believe it is best to always declare variables and functions before using them.  It takes an optional option as the second parameter which can be "nofunc" to allow named function definitions to be used before the location where they are defined.  
no-var:#:require `let` or `const` instead of `var`:#: ECMAScript 6 allows programmers to create variables with block scope instead of function scope using the let and const keywords. Block scope is common in many other programming languages and helps programmers avoid mistakes such as.  
no-void:#:Disallow use of void operator.:#: The void operator takes operand and returns undefined: void expression will evaluate expression and return undefined.  The common case of using void operator is to get "pure" undefined value as prior to ES5 undefined variable was mutable.  
no-warning-comments:#:Disallow Warning Comments:#: Often code is marked during development process for later work on it or with additional thoughts. Examples are typically // TODO: do something or // FIXME: this is not a good idea. These comments are a warning signal, that there is something not production ready in your code. Most likely you want to fix it or remove the comments before you roll out your code with a good feeling.  
no-with:#:No with Statements:#: The with statement is potentially problematic because it adds members of an object to the current scope, making it impossible to tell what a variable inside the block actually refers to. Additionally, the with statement cannot be used in strict mode.  
no-wrap-func:#:Disallow Parens Around Functions:#: Although it's possible to wrap functions in parentheses, this can be confusing when the code also contains immediately-invoked function expressions (IIFEs) since parentheses are often used to make this distinction.  
one-var:#:Require Just One var Statement Per Scope:#: JavaScript has function scope, not block scope and all variable declarations are hoisted to the top of the function. Therefore, some people believe that all variables in a function scope should be declared in a single variable declaration at the top of the function and not in multiple declarations throughout the function.  
operator-assignment:#:Operator Assignment Shorthand:#: JavaScript provides shorthand operators that combine variable assignment and some simple mathematical operations.  
padded-blocks:#:Enforce padding within blocks:#: Some style guides require block statements to start and end with blank lines. The intention of this is, to improve the readability by a visual separation of the block content and the surrounding code.  
quote-props:#:Quoting Style for Property Names:#: When configured with "always" as the first option (the default), quoting for all properties will be enforced.  
quotes:#:Enforce Quote Style:#: Enforces coding style that string literals are delimited with single or double quotes.  It takes an option as the second parameter which can be "double" or "single" for double-quotes or single-quotes respectively. There is no default.  
radix:#:Require Radix Parameter:#: When using the parseInt() function it is common to omit the second argument, the radix, and let the function try to determine from the first argument what type of number it is. By default, parseInt() will autodetect decimal and hexadecimal (via 0x prefix). Prior to ECMAScript 5, parseInt() also autodetected octal literals, which caused problems because many developers assumed a leading 0 would be ignored.  This confusion led to the suggestion that you always use the radix parameter to parseInt() to eliminate unintended consequences.  
README:#:Rules:#: Rules in ESLint are divided into several categories to help you better understand their value. Additionally, not all rules are enabled by default. Those that are not enabled by default are marked as being off.  
semi:#:Enforce Semicolons:#: JavaScript is unique amongst the C-like languages in that it doesn't require semicolons at the end of each statement.  
semi-spacing:#:Enforce spacing before and after semicolons:#: JavaScript allows you to place unnecessary spaces before or after a semicolon.  Disallowing or enforcing space around a semicolon can improve the readability of your program.  
sort-vars:#:Variable Sorting:#: When declaring multiple variables within the same block, some developers prefer to sort variable names alphabetically to be able to find necessary variable easier at the later time. Others feel that it adds complexity and becomes burden to maintain.  
space-after-function-name:#:Require or disallow spaces following function names:#: **Deprecation notice**: This rule is deprecated and has been superseded by the [space-before-function-parentheses](space-before-function-parentheses.md) rule. It will be removed in ESLint v1.0.  Whitespace between a function name and its parameter list is optional.  
space-after-keywords:#:Require or disallow spaces following keywords:#: Some style guides will require or disallow spaces following the certain keywords.  
space-before-blocks:#:Require Or Disallow Space Before Blocks:#: Consistency is an important part of any style guide. While it is a personal preference where to put the opening brace of blocks, it should be consistent across a whole project. Having an inconsistent style distracts the reader from seeing the important parts of the code.  
space-before-function-parentheses:#:Require or disallow spaces before function parentheses:#: When formatting a function, whitespace is allowed between the function name or function keyword and the opening paren.  
spaced-line-comment:#:Requires or disallows a whitespace:#: Some style guides require or disallow a whitespace immediately after the initial // of a line comment. Whitespace after the // makes it easier to read text in comments. On the other hand, commenting out code is easier without having to put a whitespace right after the //.   
space-in-brackets:#:Disallow or enforce spaces inside of brackets.:#: While formatting preferences are very personal, a number of style guides require or disallow spaces between brackets.  
space-infix-ops:#:Require Spaces Around Infix Operators:#: While formatting preferences are very personal, a number of style guides require spaces around operators.  
space-in-parens:#:Disallow or enforce spaces inside of parentheses:#: Some style guides require or disallow spaces inside of parentheses.  
space-return-throw-case:#:Require spaces following `return`, `throw`, and `case`:#: Require spaces following return, throw, and case.  
space-unary-ops:#:Require or disallow spaces before/after unary operators:#: Some styleguides require or disallow spaces before or after unary operators. This is mainly a stylistic issue, however, some JavaScript expressions can be written without spacing which makes it harder to read and maintain.  
strict:#:Strict Mode:#: A Use Strict Directive at the beginning of a script or function body enables strict mode semantics.  
use-isnan:#:Require isNaN:#: In JavaScript, NaN is a special value of the Number type. It's used to represent any of the "not-a-number" values represented by the double-precision 64-bit format as specified by the IEEE Standard for Binary Floating-Point Arithmetic. NaN has the unique property of not being equal to anything, including itself. That is to say, that the condition NaN !== NaN evaluates to true.  
valid-jsdoc:#:Validates JSDoc comments are syntactically correct:#: [JSDoc](http://usejsdoc.org) is a JavaScript API documentation generator.  
valid-typeof:#:Ensures that the results of typeof are compared against a valid string:#: For a vast majority of use-cases, the only valid results of the typeof operator will be one of the following: "undefined", "object", "boolean", "number", "string", and "function". When the result of a typeof operation is compared against a string that is not one of these strings, it is usually a typo. This rule ensures that when the result of a typeof operation is compared against a string, that string is in the aforementioned set.  
vars-on-top:#:Require Variable Declarations to be at the Top:#: The vars-on-top rule generates warnings when variable declarations are not used serially at the top of a function scope or the top of a program. By default variable declarations are always moved (“hoisted”) invisibly to the top of their containing scope by the JavaScript interpreter. This rule forces the programmer to represent that behaviour by manually moving the variable declaration to the top of its containing scope.  
wrap-iife:#:Require IIFEs to be Wrapped:#: Require immediate function invocation to be wrapped in parentheses.  
wrap-regex:#:Require Regex Literals to be Wrapped:#: When a regular expression is used in certain situation, it can end up looking like a division operator.  
yoda:#:Require or disallow Yoda Conditions:#: Yoda conditions are so named because the literal value of the condition comes first while the variable comes second.  
