no-empty-function

Disallow empty functions

Empty functions can reduce readability because readers need to guess whether it’s intentional or not. So writing a clear comment for empty functions is a good practice.

function foo() {
    // do nothing.
}
1
2
3

Especially, the empty block of arrow functions might be confusing developers. It’s very similar to an empty object literal.

list.map(() => {});   // This is a block, would return undefined.
list.map(() => ({})); // This is an empty object.
1
2

Rule Details

This rule is aimed at eliminating empty functions. A function will not be considered a problem if it contains a comment.

Examples of incorrect code for this rule:

Open in Playground

/*eslint no-empty-function: "error"*/

function foo() {}

var bar = function() {};

var bar = () => {};

function* baz() {}

var bar = function*() {};

var obj = {
    foo: function() {},

    foo: function*() {},

    foo() {},

    *foo() {},

    get foo() {},

    set foo(value) {}
};

class A {
    constructor() {}

    foo() {}

    *foo() {}

    get foo() {}

    set foo(value) {}

    static foo() {}

    static *foo() {}

    static get foo() {}

    static set foo(value) {}
}
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
38
39
40
41
42
43
44
45

Examples of correct code for this rule:

Open in Playground

/*eslint no-empty-function: "error"*/

function foo() {
    // do nothing.
}

var baz = function() {
    // any clear comments.
};

var baz = () => {
    bar();
};

function* foobar() {
    // do nothing.
}

var baz = function*() {
    // do nothing.
};

var obj = {
    foo: function() {
        // do nothing.
    },

    foo: function*() {
        // do nothing.
    },

    foo() {
        // do nothing.
    },

    *foo() {
        // do nothing.
    },

    get foo() {
        // do nothing.
    },

    set foo(value) {
        // do nothing.
    }
};

class A {
    constructor() {
        // do nothing.
    }

    foo() {
        // do nothing.
    }

    *foo() {
        // do nothing.
    }

    get foo() {
        // do nothing.
    }

    set foo(value) {
        // do nothing.
    }

    static foo() {
        // do nothing.
    }

    static *foo() {
        // do nothing.
    }

    static get foo() {
        // do nothing.
    }

    static set foo(value) {
        // do nothing.
    }
}
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

Options

This rule has an option to allow specific kinds of functions to be empty.

allow (string[]) - A list of kind to allow empty functions. List items are some of the following strings. An empty array ([]) by default.
- "functions" - Normal functions.
- "arrowFunctions" - Arrow functions.
- "generatorFunctions" - Generator functions.
- "methods" - Class methods and method shorthands of object literals.
- "generatorMethods" - Class methods and method shorthands of object literals with generator.
- "getters" - Getters.
- "setters" - Setters.
- "constructors" - Class constructors.
- "asyncFunctions" - Async functions.
- "asyncMethods" - Async class methods and method shorthands of object literals.

allow: functions

Examples of correct code for the { "allow": ["functions"] } option:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["functions"] }]*/

function foo() {}

var bar = function() {};

var obj = {
    foo: function() {}
};
1
2
3
4
5
6
7
8
9

allow: arrowFunctions

Examples of correct code for the { "allow": ["arrowFunctions"] } option:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["arrowFunctions"] }]*/

var foo = () => {};
1
2
3

allow: generatorFunctions

Examples of correct code for the { "allow": ["generatorFunctions"] } option:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["generatorFunctions"] }]*/

function* foo() {}

var bar = function*() {};

var obj = {
    foo: function*() {}
};
1
2
3
4
5
6
7
8
9

allow: methods

Examples of correct code for the { "allow": ["methods"] } option:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["methods"] }]*/

var obj = {
    foo() {}
};

class A {
    foo() {}
    static foo() {}
}
1
2
3
4
5
6
7
8
9
10

allow: generatorMethods

Examples of correct code for the { "allow": ["generatorMethods"] } option:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["generatorMethods"] }]*/

var obj = {
    *foo() {}
};

class A {
    *foo() {}
    static *foo() {}
}
1
2
3
4
5
6
7
8
9
10

allow: getters

Examples of correct code for the { "allow": ["getters"] } option:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["getters"] }]*/

var obj = {
    get foo() {}
};

class A {
    get foo() {}
    static get foo() {}
}
1
2
3
4
5
6
7
8
9
10

allow: setters

Examples of correct code for the { "allow": ["setters"] } option:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["setters"] }]*/

var obj = {
    set foo(value) {}
};

class A {
    set foo(value) {}
    static set foo(value) {}
}
1
2
3
4
5
6
7
8
9
10

allow: constructors

Examples of correct code for the { "allow": ["constructors"] } option:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["constructors"] }]*/

class A {
    constructor() {}
}
1
2
3
4
5

allow: asyncFunctions

Examples of correct code for the { "allow": ["asyncFunctions"] } options:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["asyncFunctions"] }]*/

async function a(){}
1
2
3

allow: asyncMethods

Examples of correct code for the { "allow": ["asyncMethods"] } options:

Open in Playground

/*eslint no-empty-function: ["error", { "allow": ["asyncMethods"] }]*/

var obj = {
    async foo() {}
};

class A {
    async foo() {}
    static async foo() {}
}
1
2
3
4
5
6
7
8
9
10

When Not To Use It

If you don’t want to be notified about empty functions, then it’s safe to disable this rule.

Version

This rule was introduced in ESLint v2.0.0.

Resources

Edit this page

no-empty-function

Rule Details

Options

allow: functions

allow: arrowFunctions

allow: generatorFunctions

allow: methods

allow: generatorMethods

allow: getters

allow: setters

allow: constructors

allow: asyncFunctions

allow: asyncMethods

When Not To Use It

Related Rules

Version

Resources