Arquetipo
Paso 03 de la ruta

Los 5 principios SOLID

Cinco principios de diseño orientado a objetos que ayudan a escribir código fácil de cambiar, de probar y de entender. No son leyes: son guías para tomar decisiones. Cada uno incluye un diagrama, el síntoma que te avisa de que lo estás incumpliendo y el código antes y después.

S

Responsabilidad Única

Single Responsibility Principle (SRP)
Un solo motivo para cambiar

Qué dice. Una clase debe tener un único motivo para cambiar. En la práctica, eso significa que debe responder ante un solo actor: una persona, un área o un rol del negocio que pide cambios sobre ella.

Cómo reconocer que lo incumples. Una misma clase valida datos, escribe SQL y envía correos. Cuando marketing pide cambiar el texto del correo de bienvenida, alguien toca la clase y rompe sin querer la validación que pidió el área legal.

cancelAntes: lo incumple
// ❌ Mezcla reglas de negocio, persistencia y envío de correos
export class UsuarioServicio {
  async registrar(datos: DatosUsuario) {
    if (!datos.email.includes('@')) throw new Error('Email inválido');      // validación
    await db.query('INSERT INTO usuarios (email) VALUES (?)', [datos.email]); // SQL
    await smtp.enviar(datos.email, '¡Bienvenido!');                          // correo
  }
}
check_circleDespués: lo cumple
// ✅ Cada detalle cambia en su propia clase
export class UsuarioServicio {
  constructor(
    private readonly validador: ValidadorUsuario,
    private readonly repositorio: RepositorioUsuarios,
    private readonly bienvenida: NotificadorBienvenida,
  ) {}

  async registrar(datos: DatosUsuario) {
    this.validador.validar(datos);
    const usuario = await this.repositorio.guardar(datos);
    await this.bienvenida.enviar(usuario);
  }
}

En la práctica: SRP no significa "una clase, un método". UsuarioServicio todavía coordina tres pasos, pero su único motivo para cambiar es el flujo de registro; los detalles de validar, guardar y avisar cambian en sus propias clases.

O

Abierto / Cerrado

Open/Closed Principle (OCP)
Extender sin modificar

Qué dice. El código debe estar abierto a la extensión y cerrado a la modificación: para añadir comportamiento nuevo, escribes código nuevo en lugar de cambiar el que ya funciona y está probado.

Cómo reconocer que lo incumples. Cada vez que el negocio agrega un medio de pago, alguien abre la función de cobro y añade otro else if. Cada cambio vuelve a poner en riesgo los medios que ya funcionaban.

cancelAntes: lo incumple
// ❌ Cada medio de pago nuevo modifica esta función
export function cobrar(medio: string, monto: number) {
  if (medio === 'tarjeta') {
    /* llamadas a la pasarela de tarjetas */
  } else if (medio === 'billetera') {
    /* llamadas a la billetera digital */
  } else if (medio === 'transferencia') {
    /* generar orden de transferencia */
  }
}
check_circleDespués: lo cumple
// ✅ Un medio nuevo es una clase nueva que se registra
export interface MedioPago {
  cobrar(monto: number): Promise<void>;
}

export class ProcesadorPagos {
  private medios = new Map<string, MedioPago>();

  registrar(nombre: string, medio: MedioPago) { this.medios.set(nombre, medio); }

  cobrar(nombre: string, monto: number) {
    const medio = this.medios.get(nombre);
    if (!medio) throw new Error('Medio de pago no disponible');
    return medio.cobrar(monto);
  }
}

procesador.registrar('billetera', new PagoBilletera()); // sin tocar ProcesadorPagos

En la práctica: Ningún código está cerrado a todos los cambios. OCP se aplica sobre los ejes de cambio que conoces o que se repiten (aquí, los medios de pago), no sobre cualquier posibilidad imaginable.

L

Sustitución de Liskov

Liskov Substitution Principle (LSP)
Las subclases cumplen el contrato

Qué dice. Si S es un subtipo de T, cualquier código que funcione con un T debe seguir funcionando correctamente si recibe un S. Una subclase no puede exigir más (precondiciones más estrictas), garantizar menos (postcondiciones más débiles), romper las reglas que la clase base siempre mantiene (sus invariantes, como "el saldo nunca es negativo") ni lanzar errores que la clase base no anuncia.

Cómo reconocer que lo incumples. Subclases que sobrescriben un método para lanzar "operación no soportada" o para no hacer nada. El código que usa la clase base empieza a llenarse de if (cuenta instanceof CuentaPlazoFijo).

cancelAntes: lo incumple
// ❌ La subclase rompe lo que promete la clase base
export class Cuenta {
  protected saldo = 0;
  retirar(monto: number): void { this.saldo -= monto; }
}

export class CuentaPlazoFijo extends Cuenta {
  retirar(monto: number): void {
    // Quien usa una Cuenta espera poder retirar
    throw new Error('No se puede retirar antes del vencimiento');
  }
}
check_circleDespués: lo cumple
// ✅ Cada tipo promete solo lo que puede cumplir
export interface Cuenta {
  saldo(): number;
}

export interface CuentaConRetiros extends Cuenta {
  retirar(monto: number): void;
}

export class CuentaAhorro implements CuentaConRetiros { /* saldo y retirar */ }
export class CuentaPlazoFijo implements Cuenta { /* solo saldo */ }

// Solo acepta cuentas que de verdad permiten retirar
function pagarConCuenta(cuenta: CuentaConRetiros, monto: number) {
  cuenta.retirar(monto);
}

En la práctica: La pregunta no es "¿es un?" en el mundo real, sino "¿se comporta como?" en el código. Un depósito a plazo fijo es una cuenta, pero no se comporta como una cuenta de la que se puede retirar en cualquier momento.

I

Segregación de Interfaces

Interface Segregation Principle (ISP)
Interfaces pequeñas y por rol

Qué dice. Ningún cliente debería verse obligado a depender de métodos que no usa. Es mejor tener varias interfaces pequeñas, pensadas para cada tipo de cliente, que una interfaz grande que lo abarca todo.

Cómo reconocer que lo incumples. Una interfaz con muchos métodos obliga a sus implementaciones a dejar métodos vacíos o lanzar errores, y cualquier cambio en un método que no usas te obliga a recompilar o a revisar tu código.

cancelAntes: lo incumple
// ❌ El archivo histórico es de solo lectura, pero la interfaz lo obliga a todo
export interface AlmacenDocumentos {
  leer(id: string): Promise<Documento>;
  guardar(doc: Documento): Promise<void>;
  eliminar(id: string): Promise<void>;
  generarMiniatura(id: string): Promise<Buffer>;
}

export class ArchivoHistorico implements AlmacenDocumentos {
  leer(id: string) { return this.desdeCintaDeRespaldo(id); }
  guardar(): Promise<void> { throw new Error('Solo lectura'); }    // forzado
  eliminar(): Promise<void> { throw new Error('Solo lectura'); }   // forzado
  generarMiniatura(): Promise<Buffer> { throw new Error('No soportado'); }
}
check_circleDespués: lo cumple
// ✅ Interfaces por rol: cada cliente depende solo de lo que usa
export interface LectorDocumentos {
  leer(id: string): Promise<Documento>;
}

export interface EscritorDocumentos {
  guardar(doc: Documento): Promise<void>;
  eliminar(id: string): Promise<void>;
}

export class ArchivoHistorico implements LectorDocumentos {
  leer(id: string) { return this.desdeCintaDeRespaldo(id); }
}

export class AlmacenNube implements LectorDocumentos, EscritorDocumentos { /* ... */ }

// El visor solo necesita leer: acepta cualquiera de los dos
export class VisorDocumentos {
  constructor(private readonly lector: LectorDocumentos) {}
}

En la práctica: ISP se piensa desde quien usa la interfaz, no desde quien la implementa: cada cliente declara la interfaz que necesita. Una misma clase puede implementar varias.

D

Inversión de Dependencias

Dependency Inversion Principle (DIP)
Depender de abstracciones

Qué dice. Los módulos de alto nivel (las reglas del negocio) no deben depender de los módulos de bajo nivel (base de datos, frameworks, servicios externos); ambos deben depender de abstracciones. Además, las abstracciones no deben depender de los detalles: los detalles dependen de las abstracciones.

Cómo reconocer que lo incumples. El caso de uso crea su propio driver de MySQL con las credenciales dentro. No se puede probar sin una base de datos real, y cambiar de motor obliga a reescribir la lógica de negocio.

cancelAntes: lo incumple
// ❌ La lógica de negocio depende del detalle de infraestructura
export class EmitirFactura {
  private db = new MySQLDriver('localhost', 'root', 'secreto'); // acoplamiento directo

  async ejecutar(factura: Factura) {
    await this.db.insert('facturas', factura);
  }
}
check_circleDespués: lo cumple
// ✅ El negocio define la abstracción que necesita (el "puerto")
export interface RepositorioFacturas {
  guardar(factura: Factura): Promise<void>;
}

export class EmitirFactura {
  constructor(private readonly repositorio: RepositorioFacturas) {}

  async ejecutar(factura: Factura) {
    await this.repositorio.guardar(factura);
  }
}

// La infraestructura implementa la abstracción del negocio
export class RepositorioFacturasMySQL implements RepositorioFacturas { /* ... */ }

// En las pruebas se usa una implementación en memoria
new EmitirFactura(new RepositorioFacturasEnMemoria());

En la práctica: No hay que confundir tres ideas: DIP es el principio (de qué dependes); la inyección de dependencias es una técnica para cumplirlo (recibir las dependencias desde fuera); y un contenedor IoC es una herramienta que automatiza esa inyección. Puedes cumplir DIP sin ningún contenedor.

Siguiente paso: los 23 patrones arrow_forward