id-denylist

Disallow specified identifiers

“There are only two hard things in Computer Science: cache invalidation and naming things.” — Phil Karlton

Generic names can lead to hard-to-decipher code. This rule allows you to specify a deny list of disallowed identifier names to avoid this practice.

Rule Details

This rule disallows specified identifiers in assignments and function definitions.

This rule will catch disallowed identifiers that are:

variable declarations
function declarations
object properties assigned to during object creation
class fields
class methods

It will not catch disallowed identifiers that are:

function calls (so you can still use functions you do not have control over)
object properties (so you can still use objects you do not have control over)

Options

The rule takes one or more strings as options: the names of restricted identifiers.

For example, to restrict the use of common generic identifiers:

{
    "id-denylist": ["error", "data", "err", "e", "cb", "callback"]
}
1
2
3

Note: The first element of the array is for the rule severity (see Configure Rules. The other elements in the array are the identifiers that you want to disallow.

Examples of incorrect code for this rule with sample "data", "callback" restricted identifiers:

Open in Playground

/*eslint id-denylist: ["error", "data", "callback"] */

var data = { ...values };

function callback() {
    // ...
}

element.callback = function() {
    // ...
};

var itemSet = {
    data: [...values]
};

class Foo {
    data = [];
}

class Bar {
    #data = [];
}

class Baz {
    callback() {}
}

class Qux {
    #callback() {}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Examples of correct code for this rule with sample "data", "callback" restricted identifiers:

Open in Playground

/*eslint id-denylist: ["error", "data", "callback"] */

var encodingOptions = {...values};

function processFileResult() {
    // ...
}

element.successHandler = function() {
    // ...
};

var itemSet = {
    entities: [...values]
};

callback(); // all function calls are ignored

foo.callback(); // all function calls are ignored

foo.data; // all property names that are not assignments are ignored

class Foo {
    items = [];
}

class Bar {
    #items = [];
}

class Baz {
    method() {}
}

class Qux {
    #method() {}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

When Not To Use It

You can turn this rule off if you do not want to restrict the use of certain identifiers.

Version

This rule was introduced in ESLint v7.4.0.

Resources

Edit this page