super

super([arguments]); // calls the parent constructor.
super.functionOnParent([arguments]);

Wenn ein Konstruktor verwendet wird, muss das super Schlüsselwort verwendet werden, bevor das this Schlüsselwort verwendet werden kann. Mit dem super Schlüsselwort kann man auch Funktionen im Vaterobjekt ausführen.

Der Codeabschnitt ist vom classes Beispiel (Live Demo). Hier wird super() aufgerufen, um das duplizieren von Teilen des Konstruktors zu vermeiden, was zwischen Rectangle und Square üblich ist.

class Rectangle {
  constructor(height, width) {
    this.name = 'Rectangle';
    this.height = height;
    this.width = width;
  }
  sayName() {
    console.log('Hi, I am a ', this.name + '.');
  }
  get area() {
    return this.height * this.width;
  }
  set area(value) {
    this.height = this.width = Math.sqrt(value);
  }
}

class Square extends Rectangle {
  constructor(length) {
    this.height; // ReferenceError, super needs to be called first!

    // Here, it calls the parent class' constructor with lengths
    // provided for the Polygon's width and height
    super(length, length);

    // Note: In derived classes, super() must be called before you
    // can use 'this'. Leaving this out will cause a reference error.
    this.name = 'Square';
  }
}

super kann auch in statischen Methoden verwendet werden.

class Rectangle {
  constructor() {}
  static logNbSides() {
    return 'I habe 4 sides';
  }
}

class Square extends Rectangle {
  constructor() {}
  static logDescription() {
    return super.logNbSides() + ' wich are all equal';
  }
}
Square.logDescription(); // 'I habe 4 sides wich are all equal'

Man kann den delete Operator in Verbindung mit super.prop oder super[expr] nicht einsetzen, um Eigenschaften zu löschen, es führt zu einem ReferenceError.

class Base {
  constructor() {}
  foo() {}
}
class Derived extends Base {
  constructor() {}
  delete() {
    delete super.foo;
  }
}

new Derived().delete(); // ReferenceError: invalid delete involving 'super'. 

Wenn eine schreibgeschützte Eigenschaft mit z.B. Object.defineProperty" erzeugt wird, kann der Wert nicht mit super überschrieben werden.

class X {
  constructor() {
    Object.defineProperty(this, "prop", {
      configurable: true,
      writable: false,
      value: 1
    });
  }
}

class Y extends X {
  constructor() {
    super();
  }
  foo() {
    super.prop = 2;  // Der Wert kann nicht überschrieben werden
  }
}

var y = new Y();
x.foo(); // TypeError: "prop" is read-only
console.log(y.prop); // 1

super kann auch in der object initializer / literal Notation verwendet werden. In diesem Beispiel definieren zwei Objekte eine Methode. Im zweiten Beispiel wird mit super die Funktion im ersten Objekt aufgerufen. Das funktioniert mit Hilfe von Object.setPrototypeOf() (en-US). Damit ist es möglich den Prototypen von obj2 auf obj1 zu setzen, damit super method1 in obj1 findet.

var obj1 = {
  method1() {
    console.log("method 1");
  }
}

var obj2 = {
  method2() {
   super.method1();
  }
}

Object.setPrototypeOf(obj2, obj1);
obj2.method2(); // logs "method 1"

• Klassen