Wie beginnt man als Entwickler mit der Arbeit an einem neuen Projekt?

Zuerst erfassen Sie einige grundlegende Anforderungen und beginnen dann basierend auf der Anforderung nach und nach mit der Implementierung der Funktion. Während Sie mit Ihrem Projekt fortfahren und mehr darüber erfahren, fügen Sie Ihrer Codebasis ständig Code hinzu und ändern ihn. Später ändern Sie auch den Code, um den Fehler und Randfälle zu beheben.

Aber was passiert nach ein paar Tagen oder Monaten? Wie sieht Ihr Code aus?? Ist es kompliziert? Ist es schwer zu verstehen? Wenn ja, dann haben Sie definitiv nicht darauf geachtet, Ihren Code zu verbessern oder umzustrukturieren. Möglicherweise haben Sie doppelten Code geschrieben, ohne sich den vorhandenen Code anzusehen, oder Sie haben längere Methoden/Funktionen, große Klassen, zu viele Parameter, nicht intuitive Variablennamen, Codeplatzierung usw. geschrieben.

Das Verbessern oder Aktualisieren des Codes, ohne die Funktionalität der Software oder das externe Verhalten der Anwendung zu ändern, wird als Code-Refactoring bezeichnet. Es reduziert den technischen Aufwand und macht den Code effizienter und wartbarer. Wenn Sie dem Code-Refactoring-Prozess nicht früher Aufmerksamkeit schenken, zahlen Sie später für Fehler in Ihrem Code. Ignorieren Sie also nicht die Bereinigung des Codes.

In einem Softwareentwicklungsprozess verwenden verschiedene Entwickler unterschiedliche Code-Schreibstile. Sie nehmen Änderungen vor, pflegen den Code, erweitern den Code und verlassen den Code meistens ohne kontinuierliches Refactoring. Nicht umgestalteter Code neigt dazu Code-Rot: eine Menge B. doppelter Code, ungesunde Abhängigkeiten zwischen Klassen oder Paketen, schlechte Zuordnung von Klassenverantwortlichkeiten, zu viele Verantwortlichkeiten pro Methode oder Klasse usw. Um all diese Probleme zu vermeiden, ist kontinuierliches Refactoring wichtig.

Nun ist die Frage… Welche Techniken gibt es, um den Code umzugestalten?

Wir werden einige beliebte und gängige Techniken zum Refactoring des Codes besprechen, aber vorher wollen wir noch ein paar kurze Tipps besprechen …

Tipps:

• Sie müssen das Code-Refactoring in kleinen Schritten durchführen. Nehmen Sie kleine Änderungen an Ihrem Programm vor. Jede dieser kleinen Änderungen verbessert Ihren Code ein wenig und sorgt dafür, dass die Anwendung funktionsfähig bleibt.
• Führen Sie die Test-TDD und CI aus, nachdem Sie kleine Änderungen im Refactoring-Prozess vorgenommen haben. Ohne die Durchführung dieser Tests besteht die Gefahr, dass Fehler auftreten.
• Erstellen Sie während des Refactoring-Prozesses keine neuen Features oder Funktionen. Sie sollten den Code umgestalten, bevor Sie Aktualisierungen oder neue Funktionen in Ihren vorhandenen Code einfügen.
• Der Refactoring-Prozess kann sich auf die Testergebnisse auswirken. Daher empfiehlt es sich, Ihr Qualitätssicherungs- und Testteam in den Refactoring-Prozess einzubeziehen.
• Sie müssen akzeptieren, dass Sie mit Ihrem Code nicht vollständig zufrieden sein werden. Ihr umgestalteter Code wird in naher Zukunft veraltet sein und Sie müssen ihn erneut umgestalten.

Die gängigsten Code-Refactoring-Techniken

Es gibt viele Ansätze und Techniken, den Code umzugestalten. Lassen Sie uns einige beliebte besprechen …

1. Rot-Grün-Refactoring

Rot-Grün ist die beliebteste und am weitesten verbreitete Code-Refactoring-Technik im agilen Softwareentwicklungsprozess. Diese Technik folgt dem Test-First-Ansatz für Design und Implementierung und legt die Grundlage für alle Formen des Refactorings. Entwickler ergreifen die Initiative für die Umgestaltung in den testgetriebenen Entwicklungszyklus und sie wird in den drei Bezirksschritten durchgeführt.

• ROT: Der erste Schritt beginnt mit dem Schreiben des fehlgeschlagenen Rottests. Sie bleiben stehen und prüfen, was entwickelt werden muss.
• Grün: Im zweiten Schritt schreiben Sie den einfachsten Code und bestehen den Green Test für die Entwicklung.
• Refaktor: Im letzten und dritten Schritt konzentrieren Sie sich auf die Verbesserung und Verbesserung Ihres Codes, damit Ihr Test grün bleibt.

Im Grunde besteht diese Technik also aus zwei unterschiedlichen Teilen: Im ersten Teil geht es darum, Code zu schreiben, der Ihrem System eine neue Funktion hinzufügt, und im zweiten Teil geht es um die Umgestaltung des Codes, der diese Funktion ausführt. Bedenken Sie, dass Sie während des Arbeitsablaufs nicht beides gleichzeitig tun sollten.

2. Refactoring durch Abstraktion

Diese Technik wird hauptsächlich von Entwicklern verwendet, wenn umfangreiche Refaktorierungen erforderlich sind. Wir verwenden diese Technik hauptsächlich, um die Redundanz (Duplizierung) in unserem Code zu reduzieren. Dazu gehören Klassenvererbungen, Hierarchien, die Erstellung neuer Klassen und Schnittstellen, Extraktion, Ersetzen der Vererbung durch Delegation und umgekehrt.

Hochziehen/Herunterdrücken Die Methode ist das beste Beispiel für diesen Ansatz.

• Pull-Up-Methode: Es zieht Codeteile in eine Oberklasse und hilft bei der Eliminierung von Codeduplizierungen.
• Push-Down-Methode: Es übernimmt den Codeteil einer Superklasse und verschiebt ihn bis in die Unterklassen.

Den Konstruktorkörper hochziehen, Unterklasse extrahieren, Superklasse extrahieren, Hierarchie reduzieren, Vorlagenmethode bilden, Schnittstelle extrahieren, Vererbung durch Delegation ersetzen, Delegation durch Vererbung ersetzen, Feld nach unten drücken – all das sind die anderen Beispiele.

Grundsätzlich bauen wir bei dieser Technik die Abstraktionsschicht für die Teile des Systems auf, die umgestaltet werden müssen, und für das Gegenstück, das sie schließlich ersetzen wird. Nachfolgend finden Sie zwei gängige Beispiele …

Numpy-Punktprodukt

• Gekapselt Feld: Wir erzwingen den Zugriff des Codes auf das Feld mit Getter- und Setter-Methoden.
• Typ verallgemeinern: Wir erstellen allgemeinere Typen, um die gemeinsame Nutzung von Code zu ermöglichen, Typprüfungscode durch den Status zu ersetzen, bedingte durch Polymorphismus zu ersetzen usw.

3. Kompositionsmethode

Während der Entwicklungsphase einer Anwendung schreiben wir häufig lange Methoden in unser Programm. Diese langen Methoden machen Ihren Code extrem schwer zu verstehen und schwer zu ändern. In diesen Fällen kommt meist die Kompositionsmethode zum Einsatz.

Bei diesem Ansatz verwenden wir Streamline-Methoden, um Duplikate in unserem Code zu reduzieren. Einige Beispiele sind: Methode extrahieren, Variable extrahieren, Temp einbinden, Temp durch Abfrage ersetzen, Inline-Methode, temporäre Variable teilen, Zuweisungen zu Parametern entfernen usw.

Extraktion: Wir unterteilen den Code in kleinere Teile, um Fragmentierung zu finden und zu extrahieren. Danach erstellen wir separate Methoden für diese Chunks und ersetzen sie dann durch einen Aufruf dieser neuen Methode. Die Extraktion umfasst Klassen-, Schnittstellen- und lokale Variablen.

Im Einklang: Dieser Ansatz entfernt die Anzahl unnötiger Methoden in unserem Programm. Wir finden alle Aufrufe der Methoden und ersetzen sie dann alle durch den Inhalt der Methode. Danach löschen wir die Methode aus unserem Programm.

CSS ändert die Bildgröße

4. Vereinfachende Methoden

Bei diesem Ansatz sind zwei Techniken beteiligt. Lassen Sie uns beide besprechen.

• Vereinfachtes Refactoring bedingter Ausdrücke: Bedingte Anweisung in der Programmierung wird mit der Zeit immer logischer und komplizierter. Sie müssen die Logik in Ihrem Code vereinfachen, um das gesamte Programm zu verstehen.
  Es gibt so viele Möglichkeiten, den Code umzugestalten und die Logik zu vereinfachen. Einige davon sind: Bedingungsausdruck konsolidieren und Bedingungsfragmente duplizieren, Bedingung zerlegen, Bedingung durch Polymorphismus ersetzen, Kontrollflag entfernen, verschachtelte Bedingung durch Schutzklauseln ersetzen usw.
• Vereinfachtes Refactoring von Methodenaufrufen: Bei diesem Ansatz machen wir Methodenaufrufe einfacher und verständlicher. Wir arbeiten an der Interaktion zwischen Klassen und vereinfachen die Schnittstellen dafür.
  Beispiele sind: Hinzufügen, Entfernen und Einführen neuer Parameter, Ersetzen des Parameters durch die explizite Methode und den Methodenaufruf, Parametrisieren der Methode, Erstellen einer separaten Abfrage vom Modifikator, Beibehalten des gesamten Objekts, Entfernen der Einstellungsmethode usw.

5. Verschieben von Features zwischen Objekten

Bei dieser Technik erstellen wir neue Klassen und verschieben die Funktionalität sicher zwischen alten und neuen Klassen. Wir verbergen die Implementierungsdetails vor dem öffentlichen Zugriff.

Nun stellt sich die Frage: Wann soll die Funktionalität zwischen den Klassen verschoben werden oder wie erkennt man, dass es an der Zeit ist, die Funktionen zwischen den Klassen zu verschieben?

Wenn Sie feststellen, dass eine Klasse so viele Verantwortlichkeiten hat und zu viel passiert, oder wenn Sie feststellen, dass eine Klasse unnötig ist und in einer Anwendung nichts tut, können Sie den Code von dieser Klasse in eine andere Klasse verschieben und ihn vollständig löschen.

Beispiele sind: ein Feld verschieben, eine Klasse extrahieren, eine Methode verschieben, eine Inline-Klasse verschieben, einen Delegaten ausblenden, eine fremde Methode einführen, einen Mittelsmann entfernen, eine lokale Erweiterung einführen usw.

6. Vorbereitendes Refactoring

Dieser Ansatz eignet sich am besten, wenn Sie beim Hinzufügen einiger neuer Funktionen in einer Anwendung die Notwendigkeit einer Umgestaltung feststellen. Im Grunde handelt es sich also um einen Teil eines Software-Updates mit einem separaten Refactoring-Prozess. Sie ersparen sich künftige technische Schulden, wenn Sie in früheren Phasen der Feature-Entwicklung feststellen, dass der Code aktualisiert werden muss.

Der Endbenutzer kann solche Bemühungen des Entwicklungsteams nicht auf Augenhöhe sehen, aber die Entwickler, die an der Anwendung arbeiten, werden den Wert einer Umgestaltung des Codes erkennen, wenn sie die Anwendung erstellen. Sie können Zeit, Geld und andere Ressourcen sparen, wenn sie einfach früher den Code aktualisieren.

Es ist, als ob ich 100 Meilen nach Osten fahren möchte, aber anstatt einfach durch den Wald zu schlendern, fahre ich 20 Meilen nach Norden zur Autobahn und dann fahre ich 100 Meilen nach Osten mit der dreifachen Geschwindigkeit, die ich erreichen könnte Ich bin einfach direkt dorthin gegangen. Wenn Leute einen dazu drängen, einfach direkt dorthin zu gehen, muss man manchmal sagen: „Warten Sie, ich muss auf der Karte nachsehen, um den schnellsten Weg zu finden.“ Das erledigt das vorbereitende Refactoring für mich.

Jessica Kerr (Softwareentwickler)

7. Refactoring der Benutzeroberfläche

Sie können einfache Änderungen an der Benutzeroberfläche vornehmen und den Code umgestalten. Zum Beispiel: Eingabefeld ausrichten, Schriftart anwenden, im Aktiv umformulieren, Format angeben, gemeinsame Schaltflächengröße anwenden und Farbkontrast erhöhen usw.

Letzte Worte

Sie müssen den Code-Refactoring-Prozess als Aufräumen des aufgeräumten Hauses betrachten. Unnötige Unordnung in einem Zuhause kann eine chaotische und stressige Umgebung schaffen. Das Gleiche gilt für geschriebenen Code. Ein sauberer und gut organisierter Code ist immer leicht zu ändern, leicht zu verstehen und leicht zu warten. Sie werden später keine Schwierigkeiten haben, wenn Sie sich früher mit dem Code-Refactoring-Prozess befassen.

Zwei der einflussreichsten Softwareentwickler Martin Fowler Und Kent Beck haben sich die Zeit genommen, den Code-Refactoring-Prozess und die damit verbundenen Techniken zu erklären. Sie haben auch ein vollständiges Buch zu diesem Thema geschrieben Refactoring: Verbesserung des Designs von vorhandenem Code . Dieses Buch beschreibt verschiedene Refactoring-Techniken mit einer klaren Erklärung der Arbeit an diesen Refactoring-Prozessen. Wir empfehlen Ihnen, dieses Buch zu lesen, wenn Sie sich eingehend mit dem Code-Refactoring-Prozess befassen möchten.