extends
class Hija extends Padre crea una clase que hereda todos los métodos de Padre:
class Usuario {
constructor(nombre) {
this.nombre = nombre;
}
saludar() {
return `Hola, soy ${this.nombre}`;
}
}
class Admin extends Usuario {
borrar(cosa) {
return `${this.nombre} borró ${cosa}`;
}
}
const eva = new Admin("Eva");
console.log(eva.saludar()); // heredado
console.log(eva.borrar("un comentario"));
Admin no tiene constructor, así que usa automáticamente el de Usuario.
super() en el constructor
Si la hija tiene constructor propio, tiene que llamar a super(...), el constructor del padre, antes de usar this. El objeto lo crea el padre: hasta entonces, this no existe.
class Usuario {
constructor(nombre) {
this.nombre = nombre;
}
}
class Admin extends Usuario {
constructor(nombre, nivel) {
super(nombre); // primero el padre
this.nivel = nivel; // después lo propio
}
}
console.log(new Admin("Eva", 3));
Sobrescribir y extender métodos
Si la hija define un método con el mismo nombre, tapa al del padre (lo sobrescribe). Con super.metodo() puede llamar a la versión del padre y extenderla:
class Notificacion {
texto() {
return "Tienes un mensaje";
}
}
class Urgente extends Notificacion {
texto() {
return `⚠ ${super.texto().toUpperCase()}`;
}
}
console.log(new Notificacion().texto());
console.log(new Urgente().texto());
La cadena por debajo
extends arma la cadena de prototipos que ya conoces:
admin → Admin.prototype → Usuario.prototype → Object.prototype → null
Por eso funciona instanceof: recorre la cadena buscando el prototype de la clase.
class Figura {}
class Circulo extends Figura {}
const c = new Circulo();
console.log(c instanceof Circulo, c instanceof Figura, c instanceof Object);
console.log(Object.getPrototypeOf(Circulo.prototype) === Figura.prototype);
Extender clases nativas
Puedes extender Error, Array, Map y otras clases del lenguaje. El caso más útil son los errores propios, que llevan datos extra y se distinguen con instanceof:
class ErrorHttp extends Error {
constructor(estado, mensaje) {
super(mensaje);
this.name = "ErrorHttp";
this.estado = estado;
}
}
try {
throw new ErrorHttp(404, "No encontrado");
} catch (error) {
if (error instanceof ErrorHttp) {
console.log(error.estado, error.message);
}
}
Resumen
class Hija extends Padrehereda los métodos del padre.- En un constructor hijo,
super(...)va antes de usarthis. - Un método con el mismo nombre sobrescribe;
super.metodo()llama al del padre. extendsenlaza los prototipos;instanceofrecorre esa cadena.- Extender
Errores la forma de crear errores propios con datos extra.
¡A practicar!
Tu progreso se guarda en este navegador.
Autoevaluación: extends y super
Resuelto
Elige una respuesta en cada pregunta.
¿Qué hace
class Perro extends Animal?En el constructor de una clase hija, ¿cuándo hay que llamar a
super()?¿Qué hace
super.hablar()dentro de un método?rex instanceof Animal, sirexes unPerro, ¿qué da?
Ordena la salida: Extender un método
Resuelto
Un perro que extiende el sonido de un animal. Ordena lo que aparecería en la consola.
1class Animal {2 constructor(nombre) {3 this.nombre = nombre;4 }5 hablar() {6 return `${this.nombre} hace un sonido`;7 }8}9 10class Perro extends Animal {11 hablar() {12 return `${super.hablar()}: ¡guau!`;13 }14}15 16const rex = new Perro("Rex");17console.log(rex.hablar());18console.log(rex instanceof Animal);19console.log(Object.getPrototypeOf(Perro.prototype) === Animal.prototype);20console.log(new Animal("Gato").hablar());Consola, de arriba abajo
- true
- Rex hace un sonido: ¡guau!
- Gato hace un sonido
- true
Perro no tiene constructor propio, así que usa el de Animal. Su hablar llama al del padre con super y le agrega algo. El animal genérico sigue usando su versión.
Detective: this antes de super
Resuelto
La moto nunca llega a crearse. Encuentra la línea y elige el arreglo.
Consola
vehiculos.js:9
this.marca = marca;
^
ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructorPaso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Un error propio
Resuelto
Crea ErrorDeValidacion extendiendo Error, con un dato extra: el campo que falló.
$ node programa.js
Lo que debe cumplir
- Imprime
ErrorDeValidacion email El email no es válido(pendiente) - Es un
Errorde verdad:instanceof Errordatrue(pendiente) - Usa
extends Errorysuper(mensaje)(pendiente)
Una solución
1class ErrorDeValidacion extends Error {2 constructor(campo, mensaje) {3 super(mensaje);4 this.campo = campo;5 this.name = "ErrorDeValidacion";6 }7}8 9try {10 throw new ErrorDeValidacion("email", "El email no es válido");11} catch (error) {12 console.log(error.name, error.campo, error.message);13}Extender Error es uno de los mejores usos de la herencia: tu error se comporta como cualquier otro (tiene message y stack, y funciona con instanceof), y además lleva datos propios, como el campo que falló.