Clean Code Prinzipien

Clean Code ist kein Selbstzweck, sondern die Grundlage für Software, die über Jahre hinweg gewartet und erweitert werden kann. Dieser Artikel behandelt die wichtigsten Prinzipien mit Praxisbeispielen.

Dieser Artikel ist eine Ergänzung zum clean-code-solid-prinzipien.mdx.

In a Nutshell

Clean Code bedeutet: Code so schreiben, dass andere Entwickler ihn schnell verstehen, ändern und erweitern können. Kernprinzipien: aussagekräftige Namen, kleine Funktionen, DRY, KISS, YAGNI.

Kompakte Fachbeschreibung

Clean Code ist ein Ansatz zur Softwareentwicklung, der Lesbarkeit, Wartbarkeit und Erweiterbarkeit in den Vordergrund stellt. Geprägt durch Robert C. Martin umfasst Clean Code Prinzipien wie aussagekräftige Namensgebung, kurze Funktionen mit einer Verantwortung, Vermeidung von Duplikation, Einfachheit und konsequente Refaktorisierung.

Die wichtigsten Prinzipien

1. Aussagekräftige Namen

// Schlecht
const d = 2;
const arr = getUsers();

// Gut
const DAYS_IN_WEEK = 7;
const activeUsers = users.filter(u => u.isActive);

2. Kleine Funktionen

Funktionen sollten klein sein und genau eine Sache tun.

// Schlecht: macht zu vieles
function processUser(user) {
  user.email = user.email.toLowerCase();
  user.name = user.name.trim();
  saveToDatabase(user);
  sendWelcomeEmail(user);
}

// Gut: aufgeteilt
function normalizeUser(user) {
  return { ...user, email: user.email.toLowerCase(), name: user.name.trim() };
}

async function registerUser(user) {
  const normalized = normalizeUser(user);
  await saveToDatabase(normalized);
  await sendWelcomeEmail(normalized);
}

3. DRY (Don’t Repeat Yourself)

// Schlecht: MwSt dupliziert
function calculateTotal(items) {
  return items.reduce((s, i) => s + i.price * i.qty * 1.19, 0);
}

// Gut: zentrale Konstante
const VAT_RATE = 1.19;
function calculateTotal(items) {
  return items.reduce((s, i) => s + i.price * i.qty * VAT_RATE, 0);
}

4. KISS (Keep It Simple)

// Schlecht: übertrieben abstrakt
class UserProcessor {
  constructor(strategy) { this.strategy = strategy; }
  process(user) { return this.strategy.execute(user); }
}

// Gut: einfach
function normalizeEmail(user) {
  return { ...user, email: user.email.toLowerCase() };
}

5. YAGNI (You Aren’t Gonna Need It)

Implementiere nur, was jetzt gebraucht wird.

Weitere Prinzipien

Boy Scout Rule

Hinterlasse den Code sauberer, als Du ihn vorgefunden hast.

Command-Query Separation

Eine Funktion sollte entweder etwas tun (Command) oder etwas zurückgeben (Query), nicht beides.

Error Handling

// Schlecht: Fehler verschluckt
function getData() {
  try { return fetchFromAPI(); }
  catch (e) { return null; }
}

// Gut: Fehler loggen und weitergeben
async function getData() {
  try { return await fetchFromAPI(); }
  catch (error) {
    logger.error('API fetch failed', error);
    throw new Error('Daten konnten nicht geladen werden');
  }
}

Code Smells

Smell	Beschreibung	Abhilfe
Long Method	Funktion > 30 Zeilen	Aufteilen
Large Class	Klasse > 200 Zeilen	Verantwortung aufteilen
Duplicate Code	Gleiche Logik mehrfach	Extrahieren
Long Parameter List	> 4 Parameter	Parameter-Objekt
Deep Nesting	> 3 Ebenen	Early Return / Guard Clauses
Dead Code	Nicht verwendeter Code	Löschen
Magic Numbers	Unbenannte Konstanten	Benannte Konstanten

Praxisbeispiel: Refactoring

// Vorher: unleserlich, macht zu vieles
function calc(o, c, d) {
  let r = 0;
  for (let i = 0; i < o.length; i++) {
    if (o[i].t == 'premium') r += o[i].p * 0.8;
    else if (o[i].t == 'vip') r += o[i].p * 0.7;
    else r += o[i].p;
  }
  if (d) r = r * 0.9;
  return r * 1.19;
}

// Nachher: Clean Code
const VAT_RATE = 1.19;
const DISCOUNT_MAP = { premium: 0.8, vip: 0.7, standard: 1.0 };

function applyDiscount(price, customerType) {
  const factor = DISCOUNT_MAP[customerType] ?? 1.0;
  return price * factor;
}

function calculateOrderTotal(orders, hasCoupon = false) {
  const subtotal = orders.reduce(
    (sum, order) => sum + applyDiscount(order.price, order.type), 0
  );
  const afterCoupon = hasCoupon ? subtotal * 0.9 : subtotal;
  return afterCoupon * VAT_RATE;
}

Prüfungsrelevante Stichpunkte

• DRY, KISS, YAGNI als Kernprinzipien
• Aussagekräftige Namensgebung als wichtigste Dokumentation
• Funktionen: eine Verantwortung, max. 20-30 Zeilen
• Boy Scout Rule: Code sauberer hinterlassen
• Command-Query Separation
• Code Smells erkennen und beheben
• Refactoring als kontinuierlicher Prozess

FAQ

Wenn noch Fragen offen sind, schau Dir clean-code-solid-prinzipien.mdx an .

Weiter im Softwarequalität Lernpfad

Der nächste Artikel im Softwarequalität Lernpfad behandelt SOLID Prinzipien Grundlagen — die fünf Prinzipien objektorientierten Designs: SRP, OCP, LSP, ISP und DIP.

Quellen

1. https://www.oreilly.com/library/view/clean-code/9780134661742/
2. https://clean-code-developer.com/
3. https://refactoring.com/

Buchempfehlungen zur Softwarequalität

Wenn Du Dich weiter mit Clean Code, Softwarequalität und Refactoring beschäftigen möchtest, empfehlen wir Dir die folgenden Bücher: