PILAR 01Quedarse con lo esencial
Abstracción
Abstraer es modelar solo lo que importa de un concepto para el problema que resuelves y dejar fuera el resto. Un "almacenamiento", para tu aplicación, es algo que guarda un archivo y devuelve una URL; cómo lo hace un proveedor concreto es un detalle. Las clases abstractas y las interfaces son las herramientas con las que se expresa esa idea en el código.
// El modelo esencial: para la aplicación, "almacenar" es
// subir un archivo y obtener su URL. Nada más.
export interface Almacenamiento {
subir(nombre: string, contenido: Buffer): Promise<string>;
urlDe(id: string): string;
}
// Quien lo usa trabaja con esa idea simple, no con los detalles
// (regiones, firmas, reintentos) de un proveedor concreto.
export class GestorComprobantes {
constructor(private readonly almacenamiento: Almacenamiento) {}
guardar(nombre: string, pdf: Buffer): Promise<string> {
return this.almacenamiento.subir(nombre, pdf);
}
}
Por qué importaGestorComprobantes no sabe nada del proveedor. Si mañana cambias de proveedor de almacenamiento, solo escribes otra implementación de Almacenamiento.
PILAR 02Proteger el estado
Encapsulamiento
Reúne los datos y las operaciones que los modifican dentro del mismo objeto y oculta los datos para que solo se puedan cambiar a través de esas operaciones. Así el objeto garantiza sus reglas (invariantes): por ejemplo, que el saldo nunca sea negativo.
export class CuentaBancaria {
// Estado privado: nadie desde fuera puede cambiar el saldo a su antojo
private saldo: number;
private movimientos: { fecha: Date; monto: number }[] = [];
constructor(saldoInicial: number) {
if (saldoInicial < 0) throw new Error('El saldo inicial no puede ser negativo.');
this.saldo = saldoInicial;
}
// La única forma de modificar el saldo pasa por las reglas del negocio
retirar(monto: number): void {
if (monto <= 0) throw new Error('El monto debe ser positivo.');
if (monto > this.saldo) throw new Error('Fondos insuficientes.');
this.saldo -= monto;
this.movimientos.push({ fecha: new Date(), monto: -monto });
}
obtenerSaldo(): number {
return this.saldo; // se puede leer, no escribir
}
}
Qué pasa sin élSi el saldo fuera público, cualquier parte del código podría dejarlo en negativo o cambiarlo sin registrar el movimiento, y nadie sabría desde dónde ocurrió.
PILAR 03Especializar
Herencia
Una clase hija reutiliza y especializa el comportamiento de una clase base. Es útil, pero crea uno de los acoplamientos más fuertes que existen: la hija depende de los detalles de la base, y un cambio en la base puede romper a todas sus hijas.
// Clase base con lo común a todos los notificadores
export abstract class Notificador {
protected formatear(titulo: string, cuerpo: string): string {
return '[' + new Date().toISOString() + '] ' + titulo.toUpperCase() + ': ' + cuerpo;
}
abstract enviar(destino: string, mensaje: string): Promise<void>;
}
// La subclase reutiliza el formato y especializa el envío
export class NotificadorSlack extends Notificador {
constructor(private readonly webhookUrl: string) {
super();
}
async enviar(canal: string, texto: string): Promise<void> {
const cuerpo = this.formatear('Alerta del sistema', texto);
await fetch(this.webhookUrl, { method: 'POST', body: JSON.stringify({ canal, cuerpo }) });
}
}
Regla prácticaUsa herencia cuando la hija realmente "es un" caso particular de la base y puede usarse en su lugar sin sorpresas (principio de Liskov). Si solo quieres reutilizar código, prefiere la composición.
PILAR 04Un mensaje, muchas respuestas
Polimorfismo
Permite enviar el mismo mensaje a objetos de clases distintas y que cada uno responda con su propia implementación. Quien envía el mensaje no necesita saber la clase concreta: solo que el objeto cumple el contrato.
export interface MedioDePago {
cobrar(monto: number): Promise<void>;
}
export class PagoTarjeta implements MedioDePago {
async cobrar(monto: number) { /* autoriza con la pasarela de tarjetas */ }
}
export class PagoSaldo implements MedioDePago {
async cobrar(monto: number) { /* descuenta del saldo a favor del cliente */ }
}
// Pago dividido: cada parte se cobra con su propio medio.
// El mismo mensaje (cobrar) y cada objeto responde a su manera.
export async function cobrarPedido(partes: { medio: MedioDePago; monto: number }[]) {
for (const { medio, monto } of partes) {
await medio.cobrar(monto);
}
}
await cobrarPedido([
{ medio: new PagoTarjeta(), monto: 70 },
{ medio: new PagoSaldo(), monto: 30 },
]);
La base de muchos patronesStrategy, State, Command o Composite se apoyan en el polimorfismo. Es lo que permite reemplazar los switch sobre el tipo de objeto por una sola llamada.