Configure Rules

Rules are the core building block of ESLint. A rule validates if your code meets a certain expectation, and what to do if it does not meet that expectation. Rules can also contain additional configuration options specific to that rule.

ESLint comes with a large number ofbuilt-in rules and you can add more rules through plugins. You can modify which rules your project uses with either configuration comments or configuration files.

Rule Severities

To change a rule’s severity, set the rule ID equal to one of these values:

• "off" or0 - turn the rule off.
• "warn" or1 - turn the rule on as a warning (doesn’t affect exit code).
• "error" or2 - turn the rule on as an error (exit code is 1 when triggered).

Rules are typically set to"error" to enforce compliance with the rule during continuous integration testing, pre-commit checks, and pull request merging because doing so causes ESLint to exit with a non-zero exit code.

If you don’t want to enforce compliance with a rule but would still like ESLint to report the rule’s violations, set the severity to"warn". This is typically used when introducing a new rule that will eventually be set to"error", when a rule is flagging something other than a potential buildtime or runtime error (such as an unused variable), or when a rule cannot determine with certainty that a problem has been found (when a rule might have false positives and need manual review).

Using configuration comments

To configure rules inside of a file using configuration comments, use a comment in the following format:

/* eslint eqeqeq: "off", curly: "error" */
1

In this example,eqeqeq is turned off andcurly is turned on as an error. You can also use the numeric equivalent for the rule severity:

/* eslint eqeqeq: 0, curly: 2 */
1

This example is the same as the last example, only it uses the numeric codes instead of the string values. Theeqeqeq rule is off and thecurly rule is set to be an error.

If a rule has additional options, you can specify them using array literal syntax, such as:

/* eslint quotes: ["error", "double"], curly: 2 */
1

This comment specifies the"double" option for thequotes rule. The first item in the array is always the rule severity (number or string).

Configuration Comment Descriptions

Configuration comments can include descriptions to explain why the comment is necessary. The description must occur after the configuration and is separated from the configuration by two or more consecutive- characters. For example:

/* eslint eqeqeq: "off", curly: "error" -- Here's a description about why this configuration is necessary. */
1

/* eslint eqeqeq: "off", curly: "error"    --------    Here's a description about why this configuration is necessary. */
1
2
3

/* eslint eqeqeq: "off", curly: "error" * -------- * This will not work due to the line above starting with a '*' character. */
1
2
3
4

Report unusedeslint inline config comments

To report unusedeslint inline config comments (those that don’t change anything from what was already configured), use thereportUnusedInlineConfigs setting. For example:

// eslint.config.jsimport{ defineConfig}from"eslint/config";exportdefaultdefineConfig([{linterOptions:{reportUnusedInlineConfigs:"error",},},]);
1
2
3
4
5
6
7
8
9
10

This setting defaults to"off".

This setting is similar to the--report-unused-inline-configs CLI option.

Using Configuration Files

To configure rules inside of aconfiguration file, use therules key along with an error level and any options you want to use. For example:

// eslint.config.jsimport{ defineConfig}from"eslint/config";exportdefaultdefineConfig([{rules:{eqeqeq:"off","no-unused-vars":"error","prefer-const":["error",{ignoreReadBeforeAssign:true}],},},]);
1
2
3
4
5
6
7
8
9
10
11
12

When more than one configuration object specifies the same rule, the rule configuration is merged with the later object taking precedence over any previous objects. For example:

import{ defineConfig}from"eslint/config";exportdefaultdefineConfig([{rules:{semi:["error","never"],},},{rules:{semi:["warn","always"],},},]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Using this configuration, the final rule configuration forsemi is["warn", "always"] because it appears last in the array. The array indicates that the configuration is for the severity and any options. You can change just the severity by defining only a string or number, as in this example:

import{ defineConfig}from"eslint/config";exportdefaultdefineConfig([{rules:{semi:["error","never"],},},{rules:{semi:"warn",},},]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Here, the second configuration object only overrides the severity, so the final configuration forsemi is["warn", "never"].

In aconfiguration file, for example:

// eslint.config.jsimport examplefrom"eslint-plugin-example";import{ defineConfig}from"eslint/config";exportdefaultdefineConfig([{plugins:{example,},rules:{"example/rule1":"warn",},},]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

In this configuration file, the ruleexample/rule1 comes from the plugin namedeslint-plugin-example.

You can also use this format with configuration comments, such as:

/* eslint "example/rule1": "error" */
1

/* eslint-disable */alert("foo");/* eslint-enable */
1
2
3
4
5

/* eslint-disable no-alert, no-console */alert("foo");console.log("bar");/* eslint-enable no-alert, no-console */
1
2
3
4
5
6

/* eslint-disable */alert("foo");
1
2
3

/* eslint-disable no-alert */alert("foo");
1
2
3

/* eslint no-alert: "off" */alert("foo");
1
2
3

alert("foo");// eslint-disable-line// eslint-disable-next-linealert("foo");/* eslint-disable-next-line */alert("foo");alert("foo");/* eslint-disable-line */
1
2
3
4
5
6
7
8
9

alert("foo");// eslint-disable-line no-alert// eslint-disable-next-line no-alertalert("foo");alert("foo");/* eslint-disable-line no-alert *//* eslint-disable-next-line no-alert */alert("foo");
1
2
3
4
5
6
7
8
9

alert("foo");// eslint-disable-line no-alert, quotes, semi// eslint-disable-next-line no-alert, quotes, semialert("foo");alert("foo");/* eslint-disable-line no-alert, quotes, semi *//* eslint-disable-next-line no-alert, quotes, semi */alert("foo");/* eslint-disable-next-line  no-alert,  quotes,  semi*/alert("foo");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

foo();// eslint-disable-line example/rule-namefoo();/* eslint-disable-line example/rule-name */
1
2

// eslint-disable-next-line no-console -- Here's a description about why this configuration is necessary.console.log("hello");/* eslint-disable-next-line no-console -- * Here's a very long description about why this configuration is necessary * along with some additional information **/console.log("hello");
1
2
3
4
5
6
7
8

To disable rules inside of aconfiguration file for a group of files, use a subsequent config object with afiles key. For example:

// eslint.config.jsimport{ defineConfig}from"eslint/config";exportdefaultdefineConfig([{rules:{"no-unused-expressions":"error",},},{files:["*-test.js","*.spec.js"],rules:{"no-unused-expressions":"off",},},]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Disabling Inline Comments

To disable all inline config comments, use thenoInlineConfig setting in your configuration file. For example:

// eslint.config.jsimport{ defineConfig}from"eslint/config";exportdefaultdefineConfig([{linterOptions:{noInlineConfig:true,},rules:{"no-unused-expressions":"error",},},]);
1
2
3
4
5
6
7
8
9
10
11
12
13

You can also use the--no-inline-config CLI option to disable rule comments, in addition to other in-line configuration.

Report unusedeslint-disable comments

To report unusedeslint-disable comments (those that disable rules which would not report on the disabled line), use thereportUnusedDisableDirectives setting. For example:

// eslint.config.jsimport{ defineConfig}from"eslint/config";exportdefaultdefineConfig([{linterOptions:{reportUnusedDisableDirectives:"error",},},]);
1
2
3
4
5
6
7
8
9
10

This setting defaults to"warn".

This setting is similar to--report-unused-disable-directives and--report-unused-disable-directives-severity CLI options.