The super keyword is used to call functions on an object's parent.
The super.prop
and super[expr]
expressions are valid in any method definition in both classes and object literals.
super([arguments]); // calls the parent constructor. super.functionOnParent([arguments]);
When used in a constructor, the super
keyword appears alone and must be used before the this
keyword can be used. This keyword can also be used to call functions on a parent object.
super
in classesThis code snippet is taken from the classes sample (live demo).
class Polygon { constructor(height, width) { this.name = 'Polygon'; this.height = height; this.width = width; } sayName() { console.log('Hi, I am a ', this.name + '.'); } } class Square extends Polygon { 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'; } get area() { return this.height * this.width; } set area(value) { this.area = value; } }
You are also able to call super on static methods.
class Human { constructor() {} static ping() { return 'ping'; } } class Computer extends Human { constructor() {} static pingpong() { return super.ping() + ' pong'; } } Computer.pingpong(); // 'ping pong'
You can not use the delete operator and super.prop
or super[expr]
to delete a parent class' property, it will throw a ReferenceError.
class Base { constructor() {} foo() {} } class Derived { constructor() {} delete() { delete super.foo; } } new Derived().delete(); // ReferenceError: invalid delete involving 'super'.
Super.prop
can not overwrite non-writable propertiesWhen defining non-writable properties with e.g. Object.defineProperty, super
can not overwrite the value of the property.
class X { constructor() { Object.defineProperty(this, "prop", { configurable: true, writable: false, value: 1 }); } f() { super.prop = 2; } } var x = new X(); x.f(); console.log(x.prop); // 1
super.prop
in object literalsSuper can also be used in the object initializer / literal notation. In this example, two objects define a method. In the second object, super
calls the first object's method. This works with the help of Object.setPrototypeOf() with which we are able to set the prototype of obj2
to obj1
, so that super
is able to find method1
on obj1
.
var obj1 = { method1() { console.log("method 1"); } } var obj2 = { method2() { super.method1(); } } Object.setPrototypeOf(obj2, obj1); obj2.method2(); // logs "method 1"
Created by Mozilla Contributors, license: CC-BY-SA 2.5