Les classes sont cruciales dans la programmation orientée objet, mais celles mal conçues peuvent conduire à un code problématique.

Le chapitre 10 de Clean Code souligne l'importance de classes cohésives avec une seule responsabilité.

Dans cet article, nous partagerons des informations clés et démontrerons leur application en JavaScript.

? Qu’est-ce que la cohésion de classe ?

La cohésion fait référence à l'étroitesse des responsabilités d'une classe.

Une classe cohésive se concentre sur un seul objectif et a des responsabilités qui s'emboîtent naturellement.

Cela permet de garder la classe simple, lisible et facile à maintenir.

Exemple : faible cohésion

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

Dans l'exemple ci-dessus, la classe User a trois responsabilités indépendantes : l'enregistrement des utilisateurs, l'envoi d'e-mails et l'activité de journalisation.

Cette classe manque de cohésion car elle essaie de faire trop de choses simultanément.

? Le principe de responsabilité unique (SRP)

Le principe de responsabilité unique stipule qu'une classe doit avoir une et une seule raison de changer. Cela signifie que chaque classe doit se concentrer sur une seule préoccupation.

Si une classe a plus d'une responsabilité, les changements dans un domaine pourraient interrompre la fonctionnalité d'un autre.

⚡️ Refactorisation pour SRP

Refactorisons l'exemple ci-dessus pour adhérer au 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}`);
  }
}

Désormais, chaque classe a une seule responsabilité :

• Utilisateur : représente l'objet utilisateur et contient les données.
• UserRegistrationService : gère l'enregistrement des utilisateurs.
• EmailService : gère l'envoi d'e-mails.
• ActivityLogger : gère la journalisation de l'activité des utilisateurs.

Avec cette structure, les modifications apportées au système de messagerie n'affecteront pas la logique d'enregistrement des utilisateurs, et vice versa.

? Avantages du SRP et de la cohésion

• Maintenabilité : Lorsqu'une classe a une seule responsabilité, il est plus facile de localiser et de corriger les bogues. Vous n'avez pas besoin de parcourir une logique sans rapport.

• Évolutivité : À mesure que votre projet se développe, adhérer au SRP simplifie l'ajout de nouvelles fonctionnalités. De nouvelles fonctionnalités peuvent être ajoutées dans de nouvelles classes sans toucher à celles existantes.

• Testabilité : Les classes avec une seule responsabilité sont plus faciles à tester. Chaque classe a une portée limitée, les tests unitaires peuvent donc se concentrer sur des éléments individuels de fonctionnalités.

? Identifier le chevauchement des responsabilités

Pour garantir la cohésion de vos cours, recherchez les domaines dans lesquels plusieurs responsabilités sont combinées.

Souvent, un cours commence simplement, mais à mesure que des fonctionnalités sont ajoutées, il peut accumuler des tâches supplémentaires.

Exemple : Refactorisation d'un système de paiement

Disons que nous avons une classe PaymentProcessor qui gère plusieurs tâches :

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

Ici, PaymentProcessor est responsable du traitement des paiements, de la validation des détails et de la journalisation des transactions.

C'est l'occasion de refactoriser et de répartir les responsabilités :

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

Désormais, la classe PaymentProcessor a une seule responsabilité : traiter les paiements.

La validation et la journalisation ont été déplacées vers des classes distinctes (PaymentValidator et PaymentLogger).

⚡️Conclusion

Concevoir des classes avec cohésion et adhérer au principe de responsabilité unique garantit que votre base de code reste flexible, maintenable et facile à comprendre.

En répartissant les responsabilités en classes distinctes et ciblées, vous réduisez la complexité des composants individuels et rendez votre système plus robuste.

En JavaScript, où les classes sont souvent utilisées dans des frameworks ou des applications plus vastes, le respect de ces principes améliorera considérablement la qualité de votre code.

Comme l'explique le livre Clean Code, écrire des classes propres ne consiste pas seulement à organiser le code : il s'agit également de créer un système qui peut évoluer sans devenir un cauchemar à maintenir.

Joyeux codage !