Saltar al contenido

Sección 6: JavaScript moderno, 0 de 4 lecciones completadas

Lección 19 de 22JavaScript moderno

Clases

  • 6 min de lectura
  • 3 ejercicios

Crea objetos con clases en JavaScript: constructor, propiedades, métodos, getters, campos privados con # y herencia con extends y super, con ejemplos claros.

Un molde para objetos

Si tu aplicación maneja muchos productos, cada uno con nombre, precio y la misma lógica para aplicar descuentos, escribir cada objeto a mano es repetitivo y propenso a errores. Una clase es un molde: defines la forma una vez y creas tantos objetos como quieras.

class Producto {
  constructor(nombre, precio) {
    this.nombre = nombre;
    this.precio = precio;
  }

  conDescuento(porcentaje) {
    return this.precio * (1 - porcentaje / 100);
  }
}

const teclado = new Producto("Teclado", 80);
const mouse = new Producto("Mouse", 25);

console.log(teclado.nombre);           // Teclado
console.log(mouse.conDescuento(20));   // 20

Cada objeto creado con new es una instancia de la clase. Por convención, los nombres de las clases empiezan con mayúscula.

constructor y this

El constructor es un método especial que se ejecuta al hacer new. Recibe los argumentos y prepara la instancia. Dentro, this es el objeto que se está creando: this.nombre = nombre le crea la propiedad nombre.

Si no necesitas inicializar nada, puedes omitir el constructor.

Métodos

Los métodos se escriben dentro de la clase, sin la palabra function y sin comas entre ellos. Todas las instancias comparten el mismo método, pero cada una lo ejecuta con su propio this:

class Contador {
  constructor() {
    this.valor = 0;
  }
  incrementar() {
    this.valor++;
    return this;
  }
}

const c = new Contador();
c.incrementar().incrementar();
console.log(c.valor); // 2

Devolver this permite encadenar llamadas, como arriba.

Getters

Un getter es un método que se usa como si fuera una propiedad, sin paréntesis. Sirve para valores calculados:

class Rectangulo {
  constructor(base, altura) {
    this.base = base;
    this.altura = altura;
  }
  get area() {
    return this.base * this.altura;
  }
}

const r = new Rectangulo(4, 5);
console.log(r.area); // 20

Campos privados

Un campo cuyo nombre empieza con # es privado: solo se puede leer o cambiar desde dentro de la clase. Así proteges datos que no deberían modificarse desde afuera sin control:

class Cuenta {
  #saldo = 0;

  depositar(monto) {
    if (monto <= 0) throw new Error("Monto inválido");
    this.#saldo += monto;
  }

  get saldo() {
    return this.#saldo;
  }
}

const cuenta = new Cuenta();
cuenta.depositar(100);
console.log(cuenta.saldo); // 100
// cuenta.#saldo = 1000000;  → SyntaxError: no se puede acceder desde afuera

Los campos también pueden declararse con un valor inicial fuera del constructor, como #saldo = 0. Lo mismo vale para campos públicos: stock = 0;.

También existen los métodos y propiedades static, que pertenecen a la clase y no a las instancias, como Math.max o Number.isNaN.

Herencia: extends y super

Una clase puede heredar de otra con extends. La clase hija recibe todas las propiedades y métodos de la padre y puede agregar o reemplazar los suyos:

class Animal {
  constructor(nombre) {
    this.nombre = nombre;
  }
  presentarse() {
    return "Soy " + this.nombre;
  }
}

class Perro extends Animal {
  constructor(nombre, raza) {
    super(nombre); // llama al constructor de Animal
    this.raza = raza;
  }
  presentarse() {
    return super.presentarse() + " y soy un " + this.raza;
  }
}

const firulais = new Perro("Firulais", "labrador");
console.log(firulais.presentarse()); // Soy Firulais y soy un labrador
console.log(firulais instanceof Animal); // true
  • En el constructor de una clase hija, tienes que llamar a super(...) antes de usar this.
  • super.metodo() llama a la versión de la clase padre.
  • instanceof comprueba si un objeto fue creado a partir de una clase o de alguna de sus hijas.

Puntos clave

  • Una clase es un molde para crear objetos con la misma forma y comportamiento.
  • new crea una instancia y ejecuta el constructor, que inicializa sus propiedades con this.
  • Los métodos se definen en el cuerpo de la clase y los comparten todas las instancias.
  • Los campos que empiezan con # son privados: solo se pueden usar dentro de la clase.
  • extends crea una clase hija; super llama al constructor o a los métodos de la clase padre.

Hora de practicar

Ejercicios

0/3 resueltos

Reto 1 de 3

Ejercicio 1: La clase Persona

Crea la clase Persona con:

  • un constructor que reciba nombre y edad y los guarde en la instancia;
  • un método saludar() que devuelva "Hola, soy <nombre> y tengo <edad> años".
new Persona("Rocío", 27).saludar(); // "Hola, soy Rocío y tengo 27 años"
class Persona {
  // TODO: agrega el constructor(nombre, edad)
  // TODO: agrega el método saludar()
}

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 2 de 3

Ejercicio 2: Termómetro con campo privado

Completa la clase Termometro:

  • un campo privado #celsius que empieza en 0;
  • un método fijar(grados) que lo cambie;
  • un getter fahrenheit que devuelva la temperatura en Fahrenheit (celsius * 9 / 5 + 32).
const t = new Termometro();
t.fijar(100);
t.fahrenheit; // 212
class Termometro {
  // TODO: declara el campo privado #celsius = 0
  // TODO: método fijar(grados)
  // TODO: getter fahrenheit
}

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 3 de 3

Ejercicio 3: Herencia con extends

La clase Persona ya existe. Crea la clase Empleado que herede de ella con extends:

  • su constructor recibe nombre y puesto; llama a super(nombre) y guarda puesto;
  • reemplaza presentarse() para que devuelva el texto de la clase padre más " y trabajo como <puesto>", usando super.presentarse().
new Empleado("Nora", "diseñadora").presentarse();
// "Soy Nora y trabajo como diseñadora"
class Persona {
  constructor(nombre) {
    this.nombre = nombre;
  }
  presentarse() {
    return "Soy " + this.nombre;
  }
}

// TODO: crea la clase Empleado que extienda Persona
class Empleado {
}

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

¿Has encontrado un error en esta lección? Avísanos