no-empty-function - ESLint - Pluggable JavaScript Linter (original) (raw)
Disallow empty functions
Table of Contents
- Rule Details
- Options
- allow: functions
- allow: arrowFunctions
- allow: generatorFunctions
- allow: methods
- allow: generatorMethods
- allow: getters
- allow: setters
- allow: constructors
- allow: asyncFunctions
- allow: asyncMethods
- allow: privateConstructors
- allow: protectedConstructors
- allow: decoratedFunctions
- allow: overrideMethods
- When Not To Use It
- Related Rules
- Version
- Resources
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.
}
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.
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:
/*eslint no-empty-function: "error"*/
function foo() {}
const bar = function() {};
const bar1 = () => {};
function* baz() {}
const bar2 = function*() {};
const 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) {}
}
Examples of correct code for this rule:
/*eslint no-empty-function: "error"*/
function foo() {
// do nothing.
}
const baz = function() {
// any clear comments.
};
const baz1 = () => {
bar();
};
function* foobar() {
// do nothing.
}
const baz2 = function*() {
// do nothing.
};
const 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.
}
}
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."privateConstructors"- Private class constructors. (TypeScript only)"protectedConstructors"- Protected class constructors. (TypeScript only)"decoratedFunctions"- Class methods with decorators. (TypeScript only)"overrideMethods"- Methods that use the override keyword. (TypeScript only)
allow: functions
Examples of correct code for the { "allow": ["functions"] } option:
/*eslint no-empty-function: ["error", { "allow": ["functions"] }]*/
function foo() {}
const bar = function() {};
const obj = {
foo: function() {}
};
allow: arrowFunctions
Examples of correct code for the { "allow": ["arrowFunctions"] } option:
/*eslint no-empty-function: ["error", { "allow": ["arrowFunctions"] }]*/
const foo = () => {};
allow: generatorFunctions
Examples of correct code for the { "allow": ["generatorFunctions"] } option:
/*eslint no-empty-function: ["error", { "allow": ["generatorFunctions"] }]*/
function* foo() {}
const bar = function*() {};
const obj = {
foo: function*() {}
};
allow: methods
Examples of correct code for the { "allow": ["methods"] } option:
/*eslint no-empty-function: ["error", { "allow": ["methods"] }]*/
const obj = {
foo() {}
};
class A {
foo() {}
static foo() {}
}
allow: generatorMethods
Examples of correct code for the { "allow": ["generatorMethods"] } option:
/*eslint no-empty-function: ["error", { "allow": ["generatorMethods"] }]*/
const obj = {
*foo() {}
};
class A {
*foo() {}
static *foo() {}
}
allow: getters
Examples of correct code for the { "allow": ["getters"] } option:
/*eslint no-empty-function: ["error", { "allow": ["getters"] }]*/
const obj = {
get foo() {}
};
class A {
get foo() {}
static get foo() {}
}
allow: setters
Examples of correct code for the { "allow": ["setters"] } option:
/*eslint no-empty-function: ["error", { "allow": ["setters"] }]*/
const obj = {
set foo(value) {}
};
class A {
set foo(value) {}
static set foo(value) {}
}
allow: constructors
Examples of correct code for the { "allow": ["constructors"] } option:
/*eslint no-empty-function: ["error", { "allow": ["constructors"] }]*/
class A {
constructor() {}
}
allow: asyncFunctions
Examples of correct code for the { "allow": ["asyncFunctions"] } options:
/*eslint no-empty-function: ["error", { "allow": ["asyncFunctions"] }]*/
async function a(){}
allow: asyncMethods
Examples of correct code for the { "allow": ["asyncMethods"] } options:
/*eslint no-empty-function: ["error", { "allow": ["asyncMethods"] }]*/
const obj = {
async foo() {}
};
class A {
async foo() {}
static async foo() {}
}
allow: privateConstructors
Examples of correct TypeScript code for the { "allow": ["privateConstructors"] } option:
/*eslint no-empty-function: ["error", { "allow": ["privateConstructors"] }]*/
class A {
private constructor() {}
}
allow: protectedConstructors
Examples of correct TypeScript code for the { "allow": ["protectedConstructors"] } option:
/*eslint no-empty-function: ["error", { "allow": ["protectedConstructors"] }]*/
class A {
protected constructor() {}
}
allow: decoratedFunctions
Examples of correct TypeScript code for the { "allow": ["decoratedFunctions"] } option:
/*eslint no-empty-function: ["error", { "allow": ["decoratedFunctions"] }]*/
class A {
@decorator
foo() {}
}
allow: overrideMethods
Examples of correct TypeScript code for the { "allow": ["overrideMethods"] } option:
/*eslint no-empty-function: ["error", { "allow": ["overrideMethods"] }]*/
abstract class Base {
abstract method(): void;
}
class Derived extends Base {
override method() {}
}
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.