Klassen sind in der objektorientierten Programmierung von entscheidender Bedeutung, aber schlecht gestaltete Klassen können zu problematischem Code führen.

Clean Code Kapitel 10 unterstreicht die Bedeutung zusammenhängender Klassen mit einer einzigen Verantwortung.

In diesem Artikel teilen wir wichtige Erkenntnisse und demonstrieren ihre Anwendung in JavaScript.

? Was ist Klassenzusammenhalt?

Zusammenhalt bezieht sich darauf, wie eng die Verantwortlichkeiten einer Klasse miteinander verbunden sind.

Eine zusammenhängende Klasse konzentriert sich auf einen einzigen Zweck und hat Verantwortlichkeiten, die natürlich zusammenpassen.

Dadurch bleibt die Klasse einfach, lesbar und leicht zu warten.

Beispiel: Geringe Kohä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}`);
  }
}

Im obigen Beispiel hat die Benutzerklasse drei unabhängige Verantwortlichkeiten: Benutzerregistrierung, Senden von E-Mails und Protokollieren von Aktivitäten.

Dieser Klasse mangelt es an Zusammenhalt, weil sie versucht, zu viele Dinge gleichzeitig zu erledigen.

? Das Single-Responsibility-Prinzip (SRP)

Das Single-Responsibility-Prinzip besagt, dass eine Klasse einen und nur einen Grund für eine Änderung haben sollte. Das bedeutet, dass sich jede Klasse auf ein einzelnes Anliegen konzentrieren sollte.

Wenn eine Klasse mehr als eine Verantwortung hat, können Änderungen in einem Bereich die Funktionalität eines anderen beeinträchtigen.

⚡️ Refactoring für SRP

Lassen Sie uns das obige Beispiel umgestalten, um SRP einzuhalten:

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

Jetzt hat jede Klasse eine einzige Verantwortung:

• Benutzer: stellt das Benutzerobjekt dar und enthält Daten.
• UserRegistrationService: Verwaltet die Benutzerregistrierung.
• EmailService: kümmert sich um das Versenden von E-Mails.
• ActivityLogger: Verwaltet die Protokollierung der Benutzeraktivität.

Mit dieser Struktur haben Änderungen am E-Mail-System keinen Einfluss auf die Benutzerregistrierungslogik und umgekehrt.

? Vorteile von SRP und Kohäsion

• Wartbarkeit: Wenn eine Klasse eine einzige Verantwortung hat, ist es einfacher, Fehler zu finden und zu beheben. Sie müssen sich nicht durch unabhängige Logik wühlen.

• Skalierbarkeit: Wenn Ihr Projekt wächst, erleichtert die Einhaltung von SRP das Hinzufügen neuer Funktionen. Neue Funktionalitäten können in neuen Klassen hinzugefügt werden, ohne bestehende zu berühren.

• Testbarkeit: Klassen mit einer einzelnen Verantwortung sind einfacher zu testen. Jede Klasse hat einen begrenzten Umfang, sodass sich Unit-Tests auf einzelne Funktionalitätsteile konzentrieren können.

? Identifizieren von Verantwortungsüberschneidungen

Um sicherzustellen, dass Ihre Kurse zusammenhängend sind, suchen Sie nach Bereichen, in denen mehrere Verantwortlichkeiten kombiniert werden.

Oft beginnt eine Klasse einfach, aber wenn Funktionen hinzugefügt werden, können zusätzliche Aufgaben anfallen.

Beispiel: Refactoring eines Zahlungssystems

Nehmen wir an, wir haben eine PaymentProcessor-Klasse, die mehrere Aufgaben erledigt:

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

Hier ist PaymentProcessor für die Verarbeitung von Zahlungen, die Validierung von Details und die Protokollierung von Transaktionen verantwortlich.

Dies ist eine Gelegenheit, Verantwortlichkeiten umzugestalten und aufzuteilen:

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

Jetzt hat die PaymentProcessor-Klasse eine einzige Verantwortung: die Verarbeitung von Zahlungen.

Validierung und Protokollierung wurden in separate Klassen verschoben (PaymentValidator und PaymentLogger).

⚡️ Fazit

Das Entwerfen von Klassen mit Zusammenhalt und die Einhaltung des Single-Responsibility-Prinzips stellt sicher, dass Ihre Codebasis flexibel, wartbar und leicht verständlich bleibt.

Durch die Aufteilung der Verantwortlichkeiten in separate, fokussierte Klassen reduzieren Sie die Komplexität einzelner Komponenten und machen Ihr System robuster.

In JavaScript, wo Klassen häufig in größeren Frameworks oder Anwendungen verwendet werden, wird die Befolgung dieser Prinzipien die Qualität Ihres Codes erheblich verbessern.

Wie das Clean Code-Buch erklärt, geht es beim Schreiben sauberer Klassen nicht nur um die Organisation von Code – es geht darum, ein System zu schaffen, das sich weiterentwickeln kann, ohne dass die Wartung zu einem Albtraum wird.

Viel Spaß beim Codieren!