Clean Code verstehen: Entstehung ⚡️

In Kapitel 12 von Clean Code mit dem Titel „Emergence“ wird untersucht, wie durch die Einhaltung grundlegender Designprinzipien saubere, gut strukturierte Software entsteht.

Emergenz im Softwaredesign bezieht sich auf den Prozess, durch den komplexes Verhalten oder Funktionalität aus einfachen, gut verstandenen Regeln entsteht.

Das Befolgen dieser Regeln kann Entwicklern dabei helfen, Software zu erstellen, die einfach zu warten, zu erweitern und zu verstehen ist.

---

Dieses Kapitel konzentriert sich auf die vier Regeln des einfachen Designs und legt Wert auf Einfachheit und Testbarkeit für sauberen und effizienten Code.

---

? Die vier Regeln des einfachen Designs

• Besteht alle Tests
• Zeigt Absicht
• Keine Duplizierung
• Minimiert die Anzahl der Klassen und Methoden

Lassen Sie uns jede dieser Regeln aufschlüsseln und sehen, wie sie mit JavaScript angewendet werden.

---

1. Besteht alle Tests

Die Grundlage sauberer, entstehender Software ist, dass sie funktionsfähig sein muss.

Der gesamte Code sollte seine Tests bestehen, um sicherzustellen, dass das erwartete Verhalten erhalten bleibt und neue Funktionen keine Fehler verursachen.

In JavaScript wird dies häufig durch das Schreiben von Komponententests mit Bibliotheken wie Jest oder Mocha erreicht.

function add(a, b) {
  return a + b;
}

// Test (using Jest)
test('adds 1 + 2 to equal 3', () => {
  expect(add(1, 2)).toBe(3);
});

Indem Sie sicherstellen, dass die Software alle Tests besteht, stellen Sie sicher, dass das System wie vorgesehen funktioniert.

Sauberer Code beginnt mit zuverlässigen Tests. Ohne dies sind die anderen Regeln nicht von Bedeutung.

---

2. Offenbart die Absicht

Der Code sollte kommunizieren, was er tut. Gut benannte Funktionen, Variablen und Klassen können Ihren Code ohne Kommentare einfacher lesbar und verständlich machen.

Code, der seine Absicht offenbart, ist selbsterklärend.

Schlechte Namensgebung:

function d(x) {
  return x * 2;
}

Gute Namensgebung:

function doubleNumber(number) {
  return number * 2;
}

In diesem Fall zeigt doubleNumber() deutlich die Absicht der Funktion.

Jeder, der diesen Code liest, kann seinen Zweck ohne zusätzliche Erklärungen sofort verstehen.

Diese Vorgehensweise reduziert nicht nur Verwirrung, sondern verbessert auch die Wartbarkeit.

---

3. Keine Vervielfältigung

Duplizierung im Code ist einer der größten Feinde sauberer Software. Wiederholte Logik kann zu Fehlern und erhöhtem Wartungsaufwand führen.

Ziel ist es, Redundanz zu reduzieren, indem allgemeine Verhaltensweisen in wiederverwendbare Funktionen oder Module abstrahiert werden.

Codeduplizierung:

function calculateAreaOfSquare(side) {
  return side * side;
}

function calculateAreaOfRectangle(length, width) {
  return length * width;
}

Beide Funktionen führen ähnliche Berechnungen durch. Durch Refactoring können wir Duplikate vermeiden.

Keine Vervielfältigung:

function calculateArea(shape) {
  if (shape.type === 'square') {
    return shape.side * shape.side;
  } else if (shape.type === 'rectangle') {
    return shape.length * shape.width;
  }
}

Durch die Verallgemeinerung der Funktion eliminieren wir die wiederholte Logik und machen den Code wartbarer.

---

4. Minimiert die Anzahl der Klassen und Methoden

Die letzte Regel des einfachen Designs fördert die Minimierung der Anzahl von Klassen und Methoden, ohne die Klarheit zu beeinträchtigen.

Das bedeutet, unnötige Komplexität zu vermeiden.

Jede Klasse oder Funktion sollte eine klare und fokussierte Verantwortung haben und sich an das Single Responsibility Principle (SRP) halten.

Zu viele Methoden:

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

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }

  printWelcomeMessage() {
    console.log(`Welcome, ${this.name}!`);
  }

  // Additional unrelated methods
  getUserProfile() {
    // ... some logic
  }

  logActivity() {
    // ... some logic
  }
}

Diese Klasse hat zu viele Verantwortlichkeiten. Es sollte sich nur auf die Verwaltung des Benutzernamens konzentrieren.

Überarbeitet:

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

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }
}

class Logger {
  static logActivity(user) {
    // ... some logic
    console.log(`${user.getName()} performed an activity.`);
  }
}

Durch die Trennung von Belangen wird der Code einfacher und leichter zu warten.

Jetzt hat jede Klasse eine einzige Verantwortung und hält sich an die Prinzipien des Minimalismus und der Einfachheit.

---

Abschluss

Die vier Regeln des einfachen Designs – Bestehen aller Tests, Offenlegung der Absicht, Eliminierung von Duplikaten und Minimierung der Anzahl von Klassen und Methoden – leiten die Erstellung von sauberem, wartbarem und entstehendem Code.

Durch die Befolgung dieser Prinzipien wird die Komplexität unter Kontrolle gehalten und Ihr Code wird anpassungsfähiger an Änderungen.

Viel Spaß beim Programmieren!

Das obige ist der detaillierte Inhalt vonClean Code verstehen: Entstehung ⚡️. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!