Saltar al contenido
Clases

Herencia: extends y super

Lección 3 de 511 min4 ejercicios

A veces una clase es una versión más específica de otra: un Administrador es un Usuario con permisos extra; un ErrorDeRed es un Error con más datos. La herencia permite escribir solo lo que cambia y reutilizar todo lo demás.

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 Padre hereda los métodos del padre.
  • En un constructor hijo, super(...) va antes de usar this.
  • Un método con el mismo nombre sobrescribe; super.metodo() llama al del padre.
  • extends enlaza los prototipos; instanceof recorre esa cadena.
  • Extender Error es la forma de crear errores propios con datos extra.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: extends y super

Elige una respuesta en cada pregunta.

  1. ¿Qué hace class Perro extends Animal?

  2. En el constructor de una clase hija, ¿cuándo hay que llamar a super()?

  3. ¿Qué hace super.hablar() dentro de un método?

  4. rex instanceof Animal, si rex es un Perro, ¿qué da?

Ordena la salida: Extender un método

Un perro que extiende el sonido de un animal. Ordena lo que aparecería en la consola.

class Animal {  constructor(nombre) {    this.nombre = nombre;  }  hablar() {    return `${this.nombre} hace un sonido`;  }} class Perro extends Animal {  hablar() {    return `${super.hablar()}: ¡guau!`;  }} const rex = new Perro("Rex");console.log(rex.hablar());console.log(rex instanceof Animal);console.log(Object.getPrototypeOf(Perro.prototype) === Animal.prototype);console.log(new Animal("Gato").hablar());

Consola, de arriba abajo

  1. true
  2. Rex hace un sonido: ¡guau!
  3. Gato hace un sonido
  4. true

Detective: this antes de super

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 constructor

Paso 1: toca la línea de código que causa el error.

Laboratorio: Un error propio

Crea ErrorDeValidacion extendiendo Error, con un dato extra: el campo que falló.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime ErrorDeValidacion email El email no es válido (pendiente)
  • Es un Error de verdad: instanceof Error da true (pendiente)
  • Usa extends Error y super(mensaje) (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.