Las clases son cruciales en la programación orientada a objetos, pero las mal diseñadas pueden generar código problemático.

El Capítulo 10 de Clean Code destaca la importancia de las clases cohesivas con una única responsabilidad.

En este artículo, compartiremos ideas clave y demostraremos su aplicación en JavaScript.

? ¿Qué es la cohesión de clases?

La cohesión se refiere a qué tan estrechamente relacionadas están las responsabilidades de una clase.

Una clase cohesiva se centra en un único propósito y tiene responsabilidades que naturalmente encajan entre sí.

Esto mantiene la clase simple, legible y fácil de mantener.

Ejemplo: baja cohesión

class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }

  // Handles user registration
  register() {
    // Registration logic
  }

  // Sends email to user
  sendEmail(message) {
    // Email sending logic
  }

  // Logs activity of the user
  logActivity(activity) {
    console.log(`${this.name} performed: ${activity}`);
  }
}

En el ejemplo anterior, la clase Usuario tiene tres responsabilidades no relacionadas: registro de usuario, envío de correos electrónicos y registro de actividad.

Esta clase carece de cohesión porque intenta hacer demasiadas cosas simultáneamente.

? El principio de responsabilidad única (PRS)

El principio de responsabilidad única establece que una clase debe tener una, y sólo una, razón para cambiar. Esto significa que cada clase debe centrarse en una única preocupación.

Si una clase tiene más de una responsabilidad, los cambios en un área podrían afectar la funcionalidad de otra.

⚡️ Refactorización para SRP

Refactoricemos el ejemplo anterior para cumplir con SRP:

class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }
}

class UserRegistrationService {
  register(user) {
    // Registration logic
  }
}

class EmailService {
  sendEmail(user, message) {
    // Email sending logic
  }
}

class ActivityLogger {
  logActivity(user, activity) {
    console.log(`${user.name} performed: ${activity}`);
  }
}

Ahora, cada clase tiene una única responsabilidad:

• Usuario: representa el objeto de usuario y contiene datos.
• UserRegistrationService: maneja el registro de usuarios.
• EmailService: maneja el envío de correos electrónicos.
• ActivityLogger: maneja el registro de la actividad del usuario.

Con esta estructura, los cambios en el sistema de correo electrónico no afectarán la lógica de registro del usuario, y viceversa.

? Beneficios de SRP y cohesión

• Mantenibilidad: Cuando una clase tiene una única responsabilidad, es más fácil localizar y corregir errores. No es necesario navegar por lógicas no relacionadas.

• Escalabilidad: A medida que su proyecto crece, adherirse a SRP simplifica la adición de nuevas funciones. Se pueden agregar nuevas funcionalidades en nuevas clases sin tocar las existentes.

• Testabilidad: Las clases con una sola responsabilidad son más fáciles de probar. Cada clase tiene un alcance limitado, por lo que las pruebas unitarias pueden centrarse en piezas individuales de funcionalidad.

? Identificar la superposición de responsabilidades

Para garantizar que tus clases sean coherentes, busca áreas donde se combinen múltiples responsabilidades.

A menudo, una clase comienza de manera simple, pero a medida que se agregan funciones, puede acumular tareas adicionales.

Ejemplo: Refactorización de un sistema de pago

Digamos que tenemos una clase PaymentProcessor que maneja múltiples tareas:

class PaymentProcessor {
  constructor() {
    this.paymentGateway = new PaymentGateway();
  }

  processPayment(paymentDetails) {
    // Payment processing logic
  }

  validatePaymentDetails(paymentDetails) {
    // Validation logic
  }

  logTransaction(paymentDetails) {
    console.log(`Payment processed: ${JSON.stringify(paymentDetails)}`);
  }
}

Aquí, PaymentProcessor es responsable de procesar pagos, validar detalles y registrar transacciones.

Esta es una oportunidad para refactorizar y dividir responsabilidades:

class PaymentProcessor {
  constructor(paymentGateway, validator, logger) {
    this.paymentGateway = paymentGateway;
    this.validator = validator;
    this.logger = logger;
  }

  processPayment(paymentDetails) {
    if (this.validator.isValid(paymentDetails)) {
      this.paymentGateway.process(paymentDetails);
      this.logger.logTransaction(paymentDetails);
    }
  }
}

class PaymentValidator {
  isValid(paymentDetails) {
    // Validation logic
    return true; // Simplified for example
  }
}

class PaymentLogger {
  logTransaction(paymentDetails) {
    console.log(`Payment processed: ${JSON.stringify(paymentDetails)}`);
  }
}

Ahora, la clase PaymentProcessor tiene una única responsabilidad: procesar pagos.

La validación y el registro se han movido a clases separadas (PaymentValidator y PaymentLogger).

⚡️ Conclusión

Diseñar clases con cohesión y adherirse al principio de responsabilidad única garantiza que su código base siga siendo flexible, mantenible y fácil de entender.

Al dividir las responsabilidades en clases separadas y enfocadas, reduce la complejidad de los componentes individuales y hace que su sistema sea más sólido.

En JavaScript, donde las clases se utilizan a menudo en marcos o aplicaciones más grandes, seguir estos principios mejorará significativamente la calidad de su código.

Como explica el libro Clean Code, escribir clases limpias no se trata solo de organizar el código, sino de crear un sistema que pueda evolucionar sin convertirse en una pesadilla de mantener.

¡Feliz codificación!