Refactoring
Refactoring, zu Deutsch Refaktorisierung, ist der Prozess der Umstrukturierung von Code, ohne dessen ursprüngliche Funktionalität zu verändern. Ziel des Refactoring ist es, den internen Code durch viele kleine Änderungen zu verbessern, ohne das externe Verhalten des Codes zu verändern.
Computerprogrammierer und Softwareentwickler führen Refactoring durch, um das Design, die Struktur und die Implementierung von Software zu verbessern. Refactoring verbessert die Lesbarkeit des Codes und reduziert die Komplexität. Refactoring kann Softwareentwicklern auch dabei helfen, in ihrer Software versteckte Fehler oder Schwachstellen zu finden.
Der Refactoring-Prozess umfasst viele kleine Änderungen am Quellcode eines Programms. Ein Ansatz für das Refactoring besteht beispielsweise darin, die Struktur des Quellcodes an einem Punkt zu verbessern und anschließend dieselben Änderungen systematisch auf alle anwendbaren Referenzen im gesamten Programm auszudehnen. Der Gedanke dahinter ist, dass all die kleinen, verhaltenserhaltenden Änderungen an einem Codestück einen kumulativen Effekt haben. Diese Änderungen bewahren das ursprüngliche Verhalten der Software und verändern nicht ihr Verhalten.
Martin Fowler, der als Vater des Refactoring gilt, fasste viele bewährte Praktiken aus der gesamten Softwareentwicklungsbranche in einer spezifischen Liste von Refactorings zusammen und beschrieb in seinem Buch Refactoring: Improving the Design of Existing Code Methoden zu deren Umsetzung.
Was ist der Zweck von Refactoring?
Refactoring verbessert den Code, indem es ihn:
- Effizienter durch Beseitigung von Abhängigkeiten und Komplexitäten gestaltet.
- Wartungsfreundlicher oder wiederverwendbar durch Erhöhung der Effizienz und Lesbarkeit macht.
- Sauberer organisiert, so dass er leichter zu lesen und zu verstehen ist.
- Softwareentwickler können Fehler oder Schwachstellen im Code leichter finden und beheben.
Codeänderungen werden vorgenommen, ohne dass die Funktionen des Programms selbst geändert werden. Viele grundlegende Bearbeitungsumgebungen unterstützen einfache Refactorings wie das Umbenennen einer Funktion oder Variable in einer gesamten Codebasis.
Wann sollte Code refaktorisiert werden?
Refactoring kann nach der Bereitstellung eines Produkts, vor dem Hinzufügen von Aktualisierungen und neuen Funktionen zu bestehendem Code oder als Teil der täglichen Programmierung durchgeführt werden.
Wenn der Prozess nach der Bereitstellung durchgeführt wird, geschieht dies normalerweise, bevor die Entwickler zum nächsten Projekt übergehen. Ein Unternehmen kann zu diesem Zeitpunkt im Lebenszyklus der Softwarebereitstellung mehr Code refaktorisieren, da die Entwickler eine höhere Verfügbarkeit und mehr Zeit haben, um an den erforderlichen Quellcodeänderungen zu arbeiten.
Ein besserer Zeitpunkt für das Refactoring ist jedoch vor dem Hinzufügen von Updates oder neuen Funktionen zum bestehenden Code. Wenn das Refactoring zu diesem Zeitpunkt durchgeführt wird, können die Entwickler leichter auf den vorhandenen Code aufbauen, da sie den Code vereinfachen und ihn so leichter lesen und verstehen können.
Wenn eine Organisation den Refactoring-Prozess gut beherrscht, kann sie ihn zu einem regelmäßigen Prozess machen. Wann immer ein Entwickler etwas zu einer Codebasis hinzufügen muss, kann er sich den vorhandenen Code ansehen, um zu sehen, ob er so strukturiert ist, dass das Hinzufügen von neuem Code einfach ist. Ist dies nicht der Fall, kann der Entwickler den bestehenden Code umgestalten. Sobald der neue Code hinzugefügt wurde, kann der Entwickler denselben Code erneut refaktorisieren, um ihn klarer zu gestalten.
Was sind Vorteile des Refactoring?
Refactoring kann folgende Vorteile bieten:
- Der Code wird leichter verständlich und lesbar, da das Ziel darin besteht, den Code zu vereinfachen und die Komplexität zu verringern.
- Verbessert die Wartbarkeit und erleichtert das Auffinden von Fehlern oder die Durchführung weiterer Änderungen.
- Fördert ein tieferes Verständnis des Codes. Die Entwickler müssen sich mehr Gedanken darüber machen, wie sich ihr Code mit dem bereits in der Codebasis vorhandenen Code vermischen wird.
- Der Fokus bleibt nur auf der Funktionalität. Dadurch, dass die ursprüngliche Funktionalität des Codes nicht verändert wird, wird sichergestellt, dass das ursprüngliche Projekt nicht an Umfang verliert.
Was sind Herausforderungen beim Refactoring?
Der Prozess bringt jedoch auch Herausforderungen mit sich:
- Der Prozess nimmt zusätzliche Zeit in Anspruch, wenn ein Entwicklungsteam in Eile ist und das Refactoring nicht eingeplant ist.
- Ohne klare Zielvorgaben kann das Refactoring zu Verzögerungen und Mehrarbeit führen.
- Refactoring kann Softwarefehler nicht selbst beheben, da es dazu dient, den Code zu bereinigen und weniger komplex zu machen.
Techniken für das Refactoring von Code
Unternehmen können in verschiedenen Fällen unterschiedliche Refactoring-Techniken anwenden. Einige Beispiele sind:
- Rot, grün. Diese in der agilen Entwicklung weit verbreitete Refactoring-Methode umfasst drei Schritte. Zunächst legen die Entwickler fest, was entwickelt werden muss; zweitens bringen sie ihr Projekt dazu, die Tests zu bestehen; und drittens refaktorisieren sie den Code, um Verbesserungen vorzunehmen.
- Inline. Diese Technik konzentriert sich auf die Vereinfachung des Codes durch Eliminierung unnötiger Elemente.
- Verschieben von Funktionen zwischen Objekten. Mit dieser Technik werden neue Klassen erstellt und gleichzeitig Funktionen zwischen neuen und alten Datenklassen verschoben.
- Extrahieren. Bei dieser Technik wird der Code in kleinere Teile zerlegt und diese Teile dann in eine andere Methode verschoben. Der fragmentierte Code wird durch einen Aufruf der neuen Methode ersetzt.
- Refactoring durch Abstraktion. Mit dieser Technik wird die Menge an doppeltem Code reduziert. Sie wird angewandt, wenn eine große Menge an Code überarbeitet werden muss.
- Compose. Bei dieser Technik wird der Code durch mehrere Refactoring-Methoden, einschließlich Extraktion und Inline, gestrafft, um Duplikate zu reduzieren.
Best Practices für das Refactoring von Code
Zu den bewährten Verfahren für das Refactoring gehören:
- Planen Sie das Refactoring. Andernfalls kann es schwierig sein, Zeit für diese zeitaufwändige Praxis zu finden.
- Refaktorieren Sie zuerst. Entwickler sollten dies tun, bevor sie Aktualisierungen oder neue Funktionen zum bestehenden Code hinzufügen, um technische Schulden zu reduzieren.
- Refaktorieren Sie in kleinen Schritten. Auf diese Weise erhalten die Entwickler bereits in einem frühen Stadium des Prozesses Rückmeldungen, so dass sie mögliche Fehler finden und auch geschäftliche Anforderungen berücksichtigen können.
- Setzen Sie klare Ziele. Die Entwickler sollten den Umfang und die Ziele des Projekts bereits zu Beginn des Code-Refactoring-Prozesses festlegen. Dies hilft, Verzögerungen und zusätzliche Arbeit zu vermeiden, da das Refactoring als eine Art Housekeeping gedacht ist und nicht als eine Gelegenheit, Funktionen oder Merkmale zu ändern.
- Testen Sie häufig. So können Sie sicherstellen, dass die überarbeiteten Änderungen keine neuen Fehler einführen.
- Automatisieren Sie, wo immer möglich. Automatisierungswerkzeuge machen das Refactoring einfacher und schneller und verbessern so die Effizienz.
- Beheben Sie Softwarefehler separat. Refactoring ist nicht dazu gedacht, Softwarefehler zu beheben. Fehlersuche und Debugging sollten separat durchgeführt werden.
- Verstehen Sie den Code. Überprüfen Sie den Code, um seine Prozesse, Methoden, Objekte, Variablen und andere Elemente zu verstehen.
- Refaktorieren, patchen und aktualisieren Sie regelmäßig. Refactoring ist dann am rentabelsten, wenn es ein wichtiges Problem beheben kann, ohne zu viel Zeit und Aufwand zu erfordern.
- Konzentrieren Sie sich auf Codeduplizierung. Dubletten machen den Code komplexer, vergrößern den Platzbedarf der Software und verschwenden Systemressourcen.
