eslint/id-length Style

What it does

This rule enforces a minimum and/or maximum identifier length convention by counting the graphemes for a given identifier.

Why is this bad?

Very short identifier names like e, x, _t or very long ones like hashGeneratorResultOutputContainerObject can make code harder to read and potentially less maintainable. To prevent this, one may enforce a minimum and/or maximum identifier length.

Examples

Examples of incorrect code for this rule:

/*eslint id-length: "error"*/
// default is minimum 2-chars ({ "min": 2 })

const x = 5;
obj.e = document.body;
const foo = function(e) {};
try {
  dangerousStuff();
} catch (e) {
  // ignore as many do
}
const myObj = { a: 1 };
((a) => {
  a * a;
});
class y {}
class Foo {
  x() {}
}
class Bar {
  #x() {}
}
class Baz {
  x = 1;
}
class Qux {
  #x = 1;
}
function bar(...x) {}
function baz([x]) {}
const [z] = arr;
const { prop: [i] } = {};
function qux({ x }) {}
const { j } = {};
const { prop: a } = {};
({ prop: obj.x } = {});

Examples of correct code for this rule:

/*eslint id-length: "error"*/
// default is minimum 2-chars ({ "min": 2 })

const num = 5;
function _f() {
  return 42;
}
function _func() {
  return 42;
}
obj.el = document.body;
const foo = function(evt) {/* do stuff */};
try {
  dangerousStuff();
} catch (error) {
  // ignore as many do
}
const myObj = { apple: 1 };
((num) => {
  num * num;
});
function bar(num = 0) {}
class MyClass {}
class Foo {
  method() {}
}
class Bar {
  #method() {}
}
class Baz {
  field = 1;
}
class Qux {
  #field = 1;
}
function baz(...args) {}
function qux([longName]) {}
const { prop } = {};
const { prop: [name] } = {};
const [longName] = arr;
function foobar({ prop }) {}
function foobaz({ a: prop }) {}
const { a: property } = {};
({ prop: obj.longName } = {});
const data = { "x": 1 }; // excused because of quotes
data["y"] = 3; // excused because of calculated property access

Configuration

This rule accepts a configuration object with the following properties:

exceptionPatterns

type: string[]

An array of regex patterns for identifiers to exclude from the rule. For example, ["^x.*"] would exclude all identifiers starting with "x".

exceptions

type: string[]

default: []

An array of identifier names that are excluded from the rule. For example, ["x", "y", "z"] would allow single-letter identifiers "x", "y", and "z".

max

type: integer

default: 18446744073709551615

The maximum number of graphemes allowed in an identifier. Defaults to no maximum (effectively unlimited).

min

type: integer

default: 2

The minimum number of graphemes required in an identifier.

properties

type: "always" | "never"

When set to "never", property names are not checked for length. When set to "always" (default), property names are checked just like other identifiers.

How to use

To enable this rule in the CLI or using the config file, you can use:

CLI

oxlint --deny id-length

Config (.oxlintrc.json)

{
  "rules": {
    "id-length": "error"
  }
}

References

• Rule Source