Code-Refactoring: Wie man bestehenden Code verbessert und lesbar macht

Stellen Sie sich vor: Sie öffnen einen Code, den Sie vor sechs Monaten geschrieben haben, und können nicht verstehen, was in der 200-Zeilen-Funktion mit den Variablen data1, data2, temp passiert. Kommt Ihnen das bekannt vor? Dies ist ein Signal dafür, dass der Code überarbeitet werden muss.

Was ist Refactoring?

Refactoring ist der Prozess der Änderung der internen Struktur des Codes, ohne sein externes Verhalten zu ändern. Es ist, als würde man eine Wohnung aufräumen: Die Dinge bleiben gleich, aber es wird viel einfacher, sie zu finden.

Es ist wichtig zu verstehen: Refactoring bedeutet nicht, Fehler zu beheben oder neue Funktionen hinzuzufügen. Es ist eine Verbesserung der Qualität des vorhandenen Codes, um die zukünftige Arbeit mit ihm zu erleichtern.

Wann Code umgestaltet werden muss

Es gibt mehrere klare Anzeichen dafür, dass es Zeit ist, mit dem Refactoring zu beginnen. Code-Duplikation ist ein klassisches Beispiel: Wenn Sie denselben Block an verschiedene Stellen kopieren, ist dies der erste Kandidat für die Auslagerung in eine separate Funktion. Lange Funktionen, die zu viele verschiedene Dinge tun, müssen auch in kleinere und verständlichere Teile unterteilt werden.

Schlechte Namen von Variablen und Funktionen verursachen kognitive Belastung. Wenn eine Variable x oder arr heißt, muss man sich merken, was sie bedeutet. Und ein Name wie activeUsers oder calculateTotalPrice spricht für sich.

Eine komplizierte Logik mit vielen verschachtelten Bedingungen verwandelt den Code in ein Labyrinth. Wenn Sie mehr als drei Verschachtelungsebenen if sehen, sollten Sie über ein Refactoring nachdenken.

Grundlegende Refactoring-Techniken

Extraktion der Funktion

Dies ist die häufigste Technik. Sie nehmen ein Codefragment und übertragen es in eine separate Funktion mit einem verständlichen Namen.

// Vor dem Refactoring
function processOrder(order) {
    // Validierung
    if (!order.items || order.items.length === 0) {
        throw new Error('Order is empty');
    }
    if (!order.userId) {
        throw new Error('No user specified');
    }
    
    // Berechnung des Betrags
    let total = 0;
    for (let item of order.items) {
        total += item.price * item.quantity;
    }
    
    // Anwendung des Rabatts
    if (order.promoCode) {
        total *= 0.9;
    }
    
    return total;
}

// Nach dem Refactoring
function processOrder(order) {
    validateOrder(order);
    const total = calculateTotal(order.items);
    return applyDiscount(total, order.promoCode);
}

function validateOrder(order) {
    if (!order.items || order.items.length === 0) {
        throw new Error('Order is empty');
    }
    if (!order.userId) {
        throw new Error('No user specified');
    }
}

function calculateTotal(items) {
    return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}

function applyDiscount(total, promoCode) {
    return promoCode ? total * 0.9 : total;
}

Jetzt wird die Funktion processOrder wie ein Buch gelesen: Bestellung validieren, Betrag berechnen, Rabatt anwenden. Jede Operation ist in ihrer eigenen Funktion verkapselt.

Umbenennung

Ein guter Name ist die halbe Miete. Die Variable sollte widerspiegeln, was in ihr gespeichert ist, und die Funktion, was sie tut.

# Bis
def calc(a, b, c):
    return a * b * c / 100

# Nachher
def calculate_discount_amount(price, quantity, discount_percent):
    return price * quantity * discount_percent / 100

Vereinfachung der Bedingungen

Komplexe Bedingungen können in Funktionen mit sprechenden Namen ausgegeben oder eine frühe Rückgabe verwendet werden.

// Bis
function canUserEdit(user, document) {
    if (user.isAuthenticated) {
        if (user.role === 'admin' || document.authorId === user.id) {
            if (!document.isLocked) {
                return true;
            }
        }
    }
    return false;
}

// Nachher
function canUserEdit(user, document) {
    if (!user.isAuthenticated) return false;
    if (document.isLocked) return false;
    
    return user.role === 'admin' || document.authorId === user.id;
}

Ersetzen von magischen Zahlen durch Konstanten

Magische Zahlen sind Werte, deren Bedeutung ohne Kontext unverständlich ist.

# Bis
if user.age >= 18:
    grant_access()

# Nachher
MINIMUM_AGE_FOR_ACCESS = 18

if user.age >= MINIMUM_AGE_FOR_ACCESS:
    grant_access()

Refactoring von Klassen

Bei der Arbeit mit objektorientiertem Code gibt es oft Klassen, die zu viel tun. Das Prinzip der einzigen Verantwortung besagt: Eine Klasse sollte nur einen Grund haben, sich zu ändern.

# Vorher: Die Klasse macht zu viel
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
    
    def save_to_database(self):
        # Logik des Speicherns in der Datenbank
        pass
    
    def send_welcome_email(self):
        # Logik zum Senden von E-Mails
        pass
    
    def generate_report(self):
        # Logik der Berichterstellung
        pass

# Nachher: Aufteilung der Verantwortung
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

class UserRepository:
    def save(self, user):
        # Logik des Speicherns in der Datenbank
        pass

class EmailService:
    def send_welcome_email(self, user):
        # Logik zum Senden von E-Mails
        pass

class UserReportGenerator:
    def generate(self, user):
        # Logik der Berichterstellung
        pass

Regeln für sicheres Refactoring

Refactoring ohne Tests ist ein Spiel russischer Roulette. Stellen Sie vor dem Ändern des Codes sicher, dass Sie Tests haben, die seine Funktionalität abdecken. Wenn keine Tests vorhanden sind, schreiben Sie diese vor dem Refactoring.

Machen Sie kleine Schritte. Versuchen Sie nicht, alles auf einmal umzuschreiben. Es ist besser, eine kleine Umgestaltung vorzunehmen, Tests durchzuführen, sicherzustellen, dass alles funktioniert, und erst dann mit der nächsten fortzufahren.

Häufige Commits. Jeder erfolgreiche Refactoring-Schritt ist ein separater Commit. Wenn etwas schief geht, können Sie es rückgängig machen.

Wann man nicht refaktorieren sollte

Refactoring ist kein Selbstzweck. Es gibt Situationen, in denen es besser ist, den Code so zu lassen, wie er ist. Wenn Sie an einem Prototyp arbeiten, der möglicherweise verworfen wird, ist ein tiefgreifendes Refactoring nicht sinnvoll. Wenn der Code seit Jahren stabil läuft und niemand ihn berührt, ist es möglicherweise besser, kein Risiko einzugehen.

Refaktorieren Sie auch keinen Code, den Sie nicht verstehen. Verstehen Sie zuerst, wie es funktioniert, schreiben Sie Tests und verbessern Sie erst dann die Struktur.

Refactoring-Tools

Moderne IDEs erleichtern das Refactoring erheblich. PyCharm, VS Code oder WebStorm verfügen über automatische Umbenennung von Variablen und Funktionen, Extrahieren von Methoden und Ändern von Funktionssignaturen. Verwenden Sie diese Tools, um Fehler zu vermeiden.

Linters wie ESLint für JavaScript oder Pylint für Python helfen dabei, Problembereiche im Code zu erkennen. Sie weisen auf Duplikate, zu komplexe Funktionen, ungenutzte Variablen hin.

Refactoring als Teil der Entwicklungskultur

Der beste Ansatz besteht darin, regelmäßig kleine Refactoring-Arbeiten durchzuführen, anstatt technische Schulden anzuhäufen. Die Pfadfinderregel lautet: Hinterlasse den Code sauberer, als er vor dir war. Arbeitest du mit einer Funktion? Verbessere ihren Namen. Siehst du eine Duplikation? Bring sie in die allgemeine Funktion.

Code-Review ist eine großartige Gelegenheit für Refactoring. Ein frischer Blick eines Kollegen bemerkt oft, was der Code-Autor übersehen hat.

Möchten Sie von Anfang an lernen, sauberen Code zu schreiben?

Anlage Kodik speziell für diejenigen entwickelt, die ihre ersten Schritte in der Programmierung machen. Hier lernen Sie nicht nur Theorie, sondern wenden das Wissen sofort in der Praxis an und erstellen echte Projekte. Die Kurse sind so aufgebaut, dass Sie vom ersten Tag an Code schreiben, der funktioniert und auf den Sie stolz sein können. Und wenn Sie lernen, Code zu schreiben, werden Sie lernen, wie man ihn durch Refactoring noch besser macht.

Schließen Sie sich unserem Telegram-Kanal!

Wir haben eine freundliche Entwicklergemeinschaft, in der jeder Fragen stellen kann – von den einfachsten bis zu den professionellsten. Jeden Tag analysieren wir die Top-Themen in der Entwicklung: von den Grundlagen bis hin zu fortgeschrittenen Techniken. Hier schämt man sich nicht zu fragen und bekommt immer Hilfe. Gemeinsam lernt man besser!