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 usarthis. super.metodo()llama a la versión de la clase padre.instanceofcomprueba si un objeto fue creado a partir de una clase o de alguna de sus hijas.