From a55b575e8089ee6cab7c5c262a7e6db55d0e34d6 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:46:50 +0100 Subject: unslug es: move --- .../reference/operators/super/index.html | 178 +++++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 files/es/web/javascript/reference/operators/super/index.html (limited to 'files/es/web/javascript/reference/operators/super/index.html') diff --git a/files/es/web/javascript/reference/operators/super/index.html b/files/es/web/javascript/reference/operators/super/index.html new file mode 100644 index 0000000000..ff2ac5ae0e --- /dev/null +++ b/files/es/web/javascript/reference/operators/super/index.html @@ -0,0 +1,178 @@ +--- +title: super +slug: Web/JavaScript/Referencia/Operadores/super +tags: + - Clases + - ECMAScript 2015 + - JavaScript + - Operador +translation_of: Web/JavaScript/Reference/Operators/super +--- +
{{jsSidebar("Operators")}}
+ +

La palabra clave super es usada para acceder y llamar funciones del padre de un objeto.

+ +

Las expresiones super.prop y super[expr] son válidas en cualquier definición de método tanto para clases como para objetos literales.

+ +

Sintaxis

+ +
// llama al método constructor del objeto padre.
+super([arguments]);
+
+// llama cualquier otro método del objeto padre.
+super.functionOnParent([arguments]);
+
+ +

Descripción

+ +

Cuando es usado en un constructor, la palabra clave super aparece  sola lo cual invoca el constructor del objeto padre. En este caso debe usarse antes de que la palabra clave this sea usada. La palabra clave super también puede utilizarse para llamar otras funciones del objeto padre.

+ +

Ejemplo

+ +

Usando super en clases

+ +

Este fragmento de código se toma del ejemplo de clases (demo en vivo). Aquí se llama a super() para evitar la duplicación de las partes del constructor que son comunes entre Rectangle y Square.

+ +
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 necesita ser llamado primero!
+
+    // Aquí, llama al constructor de la clase padre con las longitudes
+    // previstas para el ancho y la altura de Rectangle
+    super(length, length);
+
+    // Nota: En las clases derivadas, se debe llamar a super() antes de
+    // poder usar 'this'. Salir de esto provocará un error de referencia.
+    this.name = 'Square';
+  }
+}
+ +

Super-llamando a métodos estáticos

+ +

También puede llamar a super en métodos estáticos.

+ +
class Rectangle {
+  constructor() {}
+  static logNbSides() {
+    return 'I have 4 sides';
+  }
+}
+
+class Square extends Rectangle {
+  constructor() {}
+  static logDescription() {
+    return super.logNbSides() + ' which are all equal';
+  }
+}
+Square.logDescription(); // 'Tengo 4 lados que son todos iguales'
+
+ +

Eliminar propiedades super generará un error

+ +

No puede usar el operador de eliminación y super.prop o super[expr] para eliminar la propiedad de una clase principal, lanzará {{jsxref("ReferenceError")}}.

+ +
class Base {
+  constructor() {}
+  foo() {}
+}
+class Derived extends Base {
+  constructor() {}
+  delete() {
+    delete super.foo; // esto es malo
+  }
+}
+
+new Derived().delete(); // ReferenceError: eliminación no válida que implica 'super'. 
+ +

super.prop no puede sobrescribir las propiedades no modificables

+ +

Al definir propiedades que no se pueden escribir, p. Ej. {{jsxref("Object.defineProperty")}}, super no puede sobrescribir el valor de la propiedad.

+ +
class X {
+  constructor() {
+    Object.defineProperty(this, 'prop', {
+      configurable: true,
+      writable: false,
+      value: 1
+    });
+  }
+  f() {
+    super.prop = 2;
+  }
+}
+
+var x = new X();
+x.f(); // TypeError: "prop" es de solo lectura
+console.log(x.prop); // 1
+
+ +

Usando super.prop en objetos literales

+ +

Super también se puede usar en el inicializador de objetos / notación literal. En este ejemplo, dos objetos definen un método. En el segundo objeto, super llama al primer método del objeto. Esto funciona con la ayuda de {{jsxref("Object.setPrototypeOf()")}} con el que podemos establecer el prototipo de obj2 en obj1, de modo que super pueda encontrar el method1 en obj1.

+ +
var obj1 = {
+  method1() {
+    console.log('method 1');
+  }
+}
+
+var obj2 = {
+  method2() {
+   super.method1();
+  }
+}
+
+Object.setPrototypeOf(obj2, obj1);
+obj2.method2(); // logs "method 1"
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#sec-super-keyword', 'super')}}{{Spec2('ES2015')}}Definición inicial.
{{SpecName('ESDraft', '#sec-super-keyword', 'super')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ + + +

{{Compat("javascript.operators.super")}}

+ +

Ver también

+ + -- cgit v1.2.3-54-g00ecf