noUselessConstructor (JavaScript)

Language JavaScript (and super languages)

Summary

Rule available since: v1.0.0
Diagnostic Category: lint/complexity/noUselessConstructor
This rule is recommended, meaning it is enabled by default.
This rule has an unsafe fix.
The default severity of this rule is information.
Sources:
- Same as no-useless-constructor
- Same as @typescript-eslint/no-useless-constructor

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "complexity": {
5
        "noUselessConstructor": "error"
6
      }
7
    }
8
  }
9
}

Description

Disallow unnecessary constructors.

ES2015 provides a default class constructor if one is not specified. As such, providing an empty constructor or one that delegates into its parent is unnecessary.

The rule ignores:

decorated classes;
constructors with at least one parameter property;
private and protected constructors;
TypeScript constructors that forward at least one argument to super.

TypeScript forwarding constructors can narrow the parameter types accepted by a subclass. The rule does not compare parent and child signatures, so it ignores these constructors even when the signatures are identical.

Caveat

This rule reports on zero-argument constructors whose sole purpose is to make a parent constructor public. See the last invalid example.

Examples

Invalid

1
class A {
2
    constructor (a) {}
3
}

code-block.js:2:5 lint/complexity/noUselessConstructor  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This constructor is unnecessary.
  
    1 │ class A {
  > 2 │     constructor (a) {}
      │     ^^^^^^^^^^^^^^^^^^
    3 │ }
    4 │ 
  
  ℹ Unsafe fix: Remove the unnecessary constructor.
  
    1 1 │   class A {
    2   │ - ····constructor·(a)·{}
    3 2 │   }
    4 3 │

1
class B extends A {
2
    constructor (a) {
3
        super(a);
4
    }
5
}

code-block.js:2:5 lint/complexity/noUselessConstructor  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This constructor is unnecessary.
  
    1 │ class B extends A {
  > 2 │     constructor (a) {
      │     ^^^^^^^^^^^^^^^^^
  > 3 │         super(a);
  > 4 │     }
      │     ^
    5 │ }
    6 │ 
  
  ℹ Unsafe fix: Remove the unnecessary constructor.
  
    1 1 │   class B extends A {
    2   │ - ····constructor·(a)·{
    3   │ - ········super(a);
    4   │ - ····}
    5 2 │   }
    6 3 │

1
class C {
2
    /**
3
     * Documented constructor.
4
     */
5
    constructor () {}
6
}

code-block.js:5:5 lint/complexity/noUselessConstructor  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This constructor is unnecessary.
  
    3 │      * Documented constructor.
    4 │      */
  > 5 │     constructor () {}
      │     ^^^^^^^^^^^^^^^^^
    6 │ }
    7 │ 
  
  ℹ Unsafe fix: Remove the unnecessary constructor.
  
    1 1 │   class C {
    2   │ - ····/**
    3   │ - ·····*·Documented·constructor.
    4   │ - ·····*/
    5   │ - ····constructor·()·{}
    6 2 │   }
    7 3 │

1
class A {
2
    protected constructor() {
3
        this.prop = 1;
4
    }
5
}
6

7
class B extends A {
8
    // Make the parent constructor public.
9
    constructor () {
10
        super();
11
    }
12
}

code-block.ts:9:5 lint/complexity/noUselessConstructor  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This constructor is unnecessary.
  
     7 │ class B extends A {
     8 │     // Make the parent constructor public.
   > 9 │     constructor () {
       │     ^^^^^^^^^^^^^^^^
  > 10 │         super();
  > 11 │     }
       │     ^
    12 │ }
    13 │ 
  
  ℹ Unsafe fix: Remove the unnecessary constructor.
  
     6 6 │   
     7 7 │   class B extends A {
     8   │ - ····//·Make·the·parent·constructor·public.
     9   │ - ····constructor·()·{
    10   │ - ········super();
    11   │ - ····}
    12 8 │   }
    13 9 │

Valid

1
class A {
2
    constructor (prop) {
3
        this.prop = prop;
4
    }
5
}

1
class B extends A {
2
    constructor () {
3
        super(5);
4
    }
5
}

1
class C {
2
    // Empty constructor with parameter properties are allowed.
3
    constructor (private prop: number) {}
4
}

1
class D {
2
  constructor(public arg: number){}
3
}
4

5
class F extends D {
6
  // constructor with default parameters are allowed.
7
  constructor(arg = 4) {
8
    super(arg)
9
  }
10
}

1
class Base {
2
    constructor(public value: string | number) {}
3
}
4

5
class Narrowed extends Base {
6
    constructor(value: string) {
7
        super(value);
8
    }
9
}

1
@Decorator
2
class C {
3
    constructor (prop: number) {}
4
}