eslint/docs/rules/no-empty-function.md

   1 # Disallow empty functions (no-empty-function)
   2
   3 Empty functions can reduce readability because readers need to guess whether it's intentional or not.
   4 So writing a clear comment for empty functions is a good practice.
   5
   6 ```js
   7 function foo() {
   8     // do nothing.
   9 }
  10 ```
  11
  12 Especially, the empty block of arrow functions might be confusing developers.
  13 It's very similar to an empty object literal.
  14
  15 ```js
  16 list.map(() => {});   // This is a block, would return undefined.
  17 list.map(() => ({})); // This is an empty object.
  18 ```
  19
  20 ## Rule Details
  21
  22 This rule is aimed at eliminating empty functions.
  23 A function will not be considered a problem if it contains a comment.
  24
  25 Examples of **incorrect** code for this rule:
  26
  27 ```js
  28 /*eslint no-empty-function: "error"*/
  29 /*eslint-env es6*/
  30
  31 function foo() {}
  32
  33 var foo = function() {};
  34
  35 var foo = () => {};
  36
  37 function* foo() {}
  38
  39 var foo = function*() {};
  40
  41 var obj = {
  42     foo: function() {},
  43
  44     foo: function*() {},
  45
  46     foo() {},
  47
  48     *foo() {},
  49
  50     get foo() {},
  51
  52     set foo(value) {}
  53 };
  54
  55 class A {
  56     constructor() {}
  57
  58     foo() {}
  59
  60     *foo() {}
  61
  62     get foo() {}
  63
  64     set foo(value) {}
  65
  66     static foo() {}
  67
  68     static *foo() {}
  69
  70     static get foo() {}
  71
  72     static set foo(value) {}
  73 }
  74 ```
  75
  76 Examples of **correct** code for this rule:
  77
  78 ```js
  79 /*eslint no-empty-function: "error"*/
  80 /*eslint-env es6*/
  81
  82 function foo() {
  83     // do nothing.
  84 }
  85
  86 var foo = function() {
  87     // any clear comments.
  88 };
  89
  90 var foo = () => {
  91     bar();
  92 };
  93
  94 function* foo() {
  95     // do nothing.
  96 }
  97
  98 var foo = function*() {
  99     // do nothing.
 100 };
 101
 102 var obj = {
 103     foo: function() {
 104         // do nothing.
 105     },
 106
 107     foo: function*() {
 108         // do nothing.
 109     },
 110
 111     foo() {
 112         // do nothing.
 113     },
 114
 115     *foo() {
 116         // do nothing.
 117     },
 118
 119     get foo() {
 120         // do nothing.
 121     },
 122
 123     set foo(value) {
 124         // do nothing.
 125     }
 126 };
 127
 128 class A {
 129     constructor() {
 130         // do nothing.
 131     }
 132
 133     foo() {
 134         // do nothing.
 135     }
 136
 137     *foo() {
 138         // do nothing.
 139     }
 140
 141     get foo() {
 142         // do nothing.
 143     }
 144
 145     set foo(value) {
 146         // do nothing.
 147     }
 148
 149     static foo() {
 150         // do nothing.
 151     }
 152
 153     static *foo() {
 154         // do nothing.
 155     }
 156
 157     static get foo() {
 158         // do nothing.
 159     }
 160
 161     static set foo(value) {
 162         // do nothing.
 163     }
 164 }
 165 ```
 166
 167 ## Options
 168
 169 This rule has an option to allow specific kinds of functions to be empty.
 170
 171 * `allow` (`string[]`) - A list of kind to allow empty functions. List items are some of the following strings. An empty array (`[]`) by default.
 172     * `"functions"` - Normal functions.
 173     * `"arrowFunctions"` - Arrow functions.
 174     * `"generatorFunctions"` - Generator functions.
 175     * `"methods"` - Class methods and method shorthands of object literals.
 176     * `"generatorMethods"` - Class methods and method shorthands of object literals with generator.
 177     * `"getters"` - Getters.
 178     * `"setters"` - Setters.
 179     * `"constructors"` - Class constructors.
 180     * `"asyncFunctions"` - Async functions.
 181     * `"asyncMethods"` - Async class methods and method shorthands of object literals.
 182
 183 ### allow: functions
 184
 185 Examples of **correct** code for the `{ "allow": ["functions"] }` option:
 186
 187 ```js
 188 /*eslint no-empty-function: ["error", { "allow": ["functions"] }]*/
 189
 190 function foo() {}
 191
 192 var foo = function() {};
 193
 194 var obj = {
 195     foo: function() {}
 196 };
 197 ```
 198
 199 ### allow: arrowFunctions
 200
 201 Examples of **correct** code for the `{ "allow": ["arrowFunctions"] }` option:
 202
 203 ```js
 204 /*eslint no-empty-function: ["error", { "allow": ["arrowFunctions"] }]*/
 205 /*eslint-env es6*/
 206
 207 var foo = () => {};
 208 ```
 209
 210 ### allow: generatorFunctions
 211
 212 Examples of **correct** code for the `{ "allow": ["generatorFunctions"] }` option:
 213
 214 ```js
 215 /*eslint no-empty-function: ["error", { "allow": ["generatorFunctions"] }]*/
 216 /*eslint-env es6*/
 217
 218 function* foo() {}
 219
 220 var foo = function*() {};
 221
 222 var obj = {
 223     foo: function*() {}
 224 };
 225 ```
 226
 227 ### allow: methods
 228
 229 Examples of **correct** code for the `{ "allow": ["methods"] }` option:
 230
 231 ```js
 232 /*eslint no-empty-function: ["error", { "allow": ["methods"] }]*/
 233 /*eslint-env es6*/
 234
 235 var obj = {
 236     foo() {}
 237 };
 238
 239 class A {
 240     foo() {}
 241     static foo() {}
 242 }
 243 ```
 244
 245 ### allow: generatorMethods
 246
 247 Examples of **correct** code for the `{ "allow": ["generatorMethods"] }` option:
 248
 249 ```js
 250 /*eslint no-empty-function: ["error", { "allow": ["generatorMethods"] }]*/
 251 /*eslint-env es6*/
 252
 253 var obj = {
 254     *foo() {}
 255 };
 256
 257 class A {
 258     *foo() {}
 259     static *foo() {}
 260 }
 261 ```
 262
 263 ### allow: getters
 264
 265 Examples of **correct** code for the `{ "allow": ["getters"] }` option:
 266
 267 ```js
 268 /*eslint no-empty-function: ["error", { "allow": ["getters"] }]*/
 269 /*eslint-env es6*/
 270
 271 var obj = {
 272     get foo() {}
 273 };
 274
 275 class A {
 276     get foo() {}
 277     static get foo() {}
 278 }
 279 ```
 280
 281 ### allow: setters
 282
 283 Examples of **correct** code for the `{ "allow": ["setters"] }` option:
 284
 285 ```js
 286 /*eslint no-empty-function: ["error", { "allow": ["setters"] }]*/
 287 /*eslint-env es6*/
 288
 289 var obj = {
 290     set foo(value) {}
 291 };
 292
 293 class A {
 294     set foo(value) {}
 295     static set foo(value) {}
 296 }
 297 ```
 298
 299 ### allow: constructors
 300
 301 Examples of **correct** code for the `{ "allow": ["constructors"] }` option:
 302
 303 ```js
 304 /*eslint no-empty-function: ["error", { "allow": ["constructors"] }]*/
 305 /*eslint-env es6*/
 306
 307 class A {
 308     constructor() {}
 309 }
 310 ```
 311
 312 ### allow: asyncFunctions
 313
 314 Examples of **correct** code for the `{ "allow": ["asyncFunctions"] }` options:
 315
 316 ```js
 317 /*eslint no-empty-function: ["error", { "allow": ["asyncFunctions"] }]*/
 318 /*eslint-env es2017*/
 319
 320 async function a(){}
 321 ```
 322
 323 ### allow: asyncMethods
 324
 325 Examples of **correct** code for the `{ "allow": ["asyncMethods"] }` options:
 326
 327 ```js
 328 /*eslint no-empty-function: ["error", { "allow": ["asyncMethods"] }]*/
 329 /*eslint-env es2017*/
 330
 331 var obj = {
 332     async foo() {}
 333 };
 334
 335 class A {
 336     async foo() {}
 337     static async foo() {}
 338 }
 339 ```
 340
 341 ## When Not To Use It
 342
 343 If you don't want to be notified about empty functions, then it's safe to disable this rule.
 344
 345 ## Related Rules
 346
 347 * [no-empty](./no-empty.md)