As classes são cruciais na programação orientada a objetos, mas aquelas mal projetadas podem levar a códigos problemáticos.

Clean Code Capítulo 10 destaca a importância de classes coesas com uma única responsabilidade.

Neste artigo, compartilharemos os principais insights e demonstraremos sua aplicação em JavaScript.

? O que é coesão de classe?

Coesão refere-se ao quão intimamente relacionadas estão as responsabilidades de uma classe.

Uma turma coesa concentra-se em um único propósito e tem responsabilidades que se encaixam naturalmente.

Isso mantém a classe simples, legível e fácil de manter.

Exemplo: baixa coesão

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}`);
  }
}

No exemplo acima, a classe User tem três responsabilidades não relacionadas: registro do usuário, envio de e-mails e registro de atividades.

Esta classe carece de coesão porque tenta fazer muitas coisas simultaneamente.

? O Princípio da Responsabilidade Única (SRP)

O Princípio da Responsabilidade Única afirma que uma classe deve ter um, e apenas um, motivo para mudar. Isso significa que cada aula deve se concentrar em uma única preocupação.

Se uma classe tiver mais de uma responsabilidade, alterações em uma área podem quebrar a funcionalidade de outra.

⚡️ Refatoração para SRP

Vamos refatorar o exemplo acima para aderir ao 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}`);
  }
}

Agora, cada turma tem uma única responsabilidade:

• Usuário: representa o objeto do usuário e contém dados.
• UserRegistrationService: trata do registro do usuário.
• EmailService: trata do envio de e-mails.
• ActivityLogger: lida com o registro da atividade do usuário.

Com esta estrutura, alterações no sistema de e-mail não afetarão a lógica de registro do usuário e vice-versa.

? Benefícios do SRP e da Coesão

• Manutenção: Quando uma classe tem uma única responsabilidade, é mais fácil localizar e corrigir bugs. Você não precisa percorrer lógicas não relacionadas.

• Escalabilidade: À medida que seu projeto cresce, aderir ao SRP torna mais simples adicionar novos recursos. Novas funcionalidades podem ser adicionadas em novas classes sem alterar as existentes.

• Testabilidade: Classes com uma única responsabilidade são mais fáceis de testar. Cada classe tem um escopo limitado, portanto, os testes de unidade podem se concentrar em peças individuais de funcionalidade.

? Identificando sobreposição de responsabilidades

Para garantir que suas aulas sejam coesas, procure áreas onde múltiplas responsabilidades estão sendo combinadas.

Muitas vezes, uma aula começa simples, mas à medida que recursos são adicionados, ela pode acumular tarefas extras.

Exemplo: refatorando um sistema de pagamento

Digamos que temos uma classe PaymentProcessor que lida com múltiplas tarefas:

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)}`);
  }
}

Aqui, PaymentProcessor é responsável por processar pagamentos, validar detalhes e registrar transações.

Esta é uma oportunidade para refatorar e 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)}`);
  }
}

Agora, a classe PaymentProcessor tem uma única responsabilidade: processar pagamentos.

Validação e registro foram movidos para classes separadas (PaymentValidator e PaymentLogger).

⚡️ Conclusão

Projetar classes com coesão e aderir ao Princípio de Responsabilidade Única garante que sua base de código permaneça flexível, sustentável e fácil de entender.

Ao dividir as responsabilidades em classes separadas e focadas, você reduz a complexidade dos componentes individuais e torna seu sistema mais robusto.

Em JavaScript, onde as classes são frequentemente usadas em estruturas ou aplicativos maiores, seguir esses princípios melhorará significativamente a qualidade do seu código.

Como explica o livro Clean Code, escrever classes limpas não se trata apenas de organizar o código - trata-se de criar um sistema que pode evoluir sem se tornar um pesadelo para manter.

Boa codificação!