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}`);
}
}
Nach dem Login kopieren
Im obigen Beispiel hat die Benutzerklasse drei voneinander unabhängige Verantwortlichkeiten: Benutzerregistrierung, Senden von E-Mails und Protokollieren von Aktivitäten.
Diesem Kurs mangelt es an Zusammenhalt, weil er 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}`);
}
}
Nach dem Login kopieren
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 nur 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 einzigen 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 ein Kurs einfach, aber wenn Funktionen hinzugefügt werden, können sich zusätzliche Aufgaben ansammeln.
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)}`);
}
}
Nach dem Login kopieren
Hier ist PaymentProcessor für die Verarbeitung von Zahlungen, die Validierung von Details und die Protokollierung von Transaktionen verantwortlich.
Dies ist eine Gelegenheit, die 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)}`);
}
}
Nach dem Login kopieren
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 Prinzips der Einzelverantwortung 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 oft 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 Programmieren!
Das obige ist der detaillierte Inhalt vonClean Code verstehen: Klassen ⚡️. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
