When do I need to call `super` from a constructor?

Question

Reading Dr. Axel Rauschmayer's blog on ES6 classes, I understand that a derived class has the following default constructor when none is provided

constructor(...args) {
    super(...args);
}

I also understand that if I want to use this within a constructor I first need to call super, otherwise this will not yet be initialized (throwing a ReferenceError).

constructor(width, height) {
    this.width = width;  // ReferenceError
    super(width, height);
    this.height = height; // no error thrown
    ...
}

Is the following assumption then correct? (and if not, could you please explain the conditions under which I should explicitly call super)

For derived classes, I only need to explicitly call super when...

1. I need to access this from within the constructor
2. The superclass constructor requires different arguments then the derived class constructor

Are there other times when I should include a call to the superclass constructor?

Answer 1

Yes, that sounds correct, albeit a bit oddly formulated. The rules should be

• In a derived class, you always¹ need to call the super(…) constructor
• If you are not doing more than the default constructor, you can omit the whole constructor(){}, which in turn will make your class code not contain a super call.

_{1: You don't need to call it in the suspicious edge case of explicitly returning an object, which you hardly ever would.}

Answer 2

You need to call super in a subclass constructor in these cases:

• You want to reference this in the subclass constructor
• You don't return a different object in the subclass constructor

In other cases, you can call it if you want the superclass constructor to run, but you don't have to.

class SuperClass{
  constructor() {
    console.log('SuperClass');
  }
}
class SubClass1 extends SuperClass {
  constructor() {
    console.log('SubClass1');
    super();
    return {};
  }
}
class SubClass2 extends SuperClass {
  constructor() {
    console.log('SubClass2');
    return {};
  }
}
new SubClass1();
new SubClass2();

I don't see how the order of arguments matters when deciding whether you should call super or not.