Sauberer Code: Prinzipien, Vorteile und Beispiele
Der Begriff Clean Code wird dem Softwareentwickler Robert Cecil Martin zugeschrieben, der ihn in seinem Buch Clean Code: Refactoring, Muster, Tests und Techniken für Clean Code verwendet hat, um sich auf Clean Code zu beziehen . Ihre Prinzipien sind jedoch viel älter und stammen nicht aus dem Bereich der Programmierung. Wir erklären, woraus der saubere Code besteht , welche Vorteile er hat und wie er entwickelt wird.
- Sauberer Code: Was ist das?
- Sauberer Code: Allgemeine Prinzipien
- So einfach wie möglich: KISS
- Vermeiden Sie es, ohne Grund zu wiederholen: TROCKEN
- Beseitigen Sie das Unnötige: YAGNI
- Lesbar statt prägnant
Sauberer Code: Was ist das?
Bei der Codebereinigung handelt es sich nicht um strenge Regeln, sondern um eine Reihe von Prinzipien, mit denen sich intuitiver und einfach zu ändernder Code erstellen lässt. Intuitiv bedeutet in diesem Zusammenhang, dass jeder professionelle Entwickler es sofort verstehen kann. Ein leicht anpassbarer Code weist die folgenden Merkmale auf:
- Die Reihenfolge der Ausführung des gesamten Programms folgt einer Logik und es hat eine einfache Struktur .
- Die Beziehung zwischen den verschiedenen Teilen des Codes ist deutlich sichtbar .
- Die Aufgabe oder Funktion jeder Klasse, Funktion, Methode und Variablen ist auf den ersten Blick verständlich .
Ein Code kann als einfach zu ändern angesehen werden, wenn er flexibel und erweiterbar ist. Dies hilft auch dabei, eventuelle Fehler zu korrigieren. Daher ist sauberer Code sehr einfach zu pflegen und weist die folgenden Eigenschaften auf:
- Klassen und Methoden werden reduziert und haben, wenn möglich, eine einzige klare Aufgabe.
- Klassen und Methoden sind vorhersehbar , funktionieren wie erwartet und sind über gut dokumentierte APIs (Schnittstellen) öffentlich zugänglich.
- Der Code wurde Unit-getestet .
Die Vorteile dieser Art der Programmierung liegen auf der Hand: Der saubere Code wird unabhängig von dem Entwickler, der ihn erstellt hat . Grundsätzlich kann jeder Programmierer damit arbeiten, wodurch Probleme wie die mit Legacy-Code verbundenen vermieden werden. Die Wartung der Software wird ebenfalls vereinfacht , da die Fehler leichter zu finden und zu beheben sind.
Sauberer Code: Allgemeine Prinzipien
Wie schreibe ich sauberen Code? Erstellen von sauberem Code beinhaltet hält im Auge bei der Softwareentwicklung bestimmte Grundprinzipien . Es geht nicht darum, bestimmte Anweisungen zu befolgen, die angeben, wie in bestimmten Situationen programmiert werden soll, sondern um die Selbstreflexion Ihrer eigenen Arbeit. Aus diesem Grund löst seine Bedeutung Kontroversen in der Entwicklergemeinde aus: Was manche als “sauber” betrachten, kann “schmutzig” sein. für andere ist die Sauberkeit des Codes etwas subjektiv. Hier sind einige sehr verbreitete Prinzipien für sauberen Code, die fast alle Entwickler nützlich finden.
So einfach wie möglich: KISS
KISS ( k eep i t s Umset , s buschig oder? Halten Sie es einfach, dumm?) Ist eine der ältesten sauberen Code Prinzipien, die bereits in Verwendung durch das US – Militär in den 1960er Jahren. KISS erinnert Entwickler dass der Code so einfach wie möglich sein sollte , um unnötige Komplexität zu vermeiden. In der Programmierung gibt es nie einen einzigen Weg, um ein Problem zu lösen. Aufgaben können immer in verschiedenen Sprachen ausgedrückt und mit verschiedenen Befehlen formuliert werden. Programmierer, die dem KISS-Prinzip folgen, sollten sich daher immer fragen, ob sie eine einfachere Lösung für ein bestimmtes Problem finden könnten.
Vermeiden Sie es, ohne Grund zu wiederholen: TROCKEN
TROCKEN (aus dem Englischen d auf? t r epeat und sie selbst , oder? Sie sich nicht wiederholen?) ist eine KISS Realisierung. Nach dem DRY-Prinzip muss jede Funktion eine eindeutige und daher eindeutige Darstellung innerhalb des allgemeinen Clean-Code-Systems haben.
Das Gegenteil von DRY ist WET ( w e e njoy t yping oder? Wir hatten eine gute Typisierung?). Der Code ist WET, wenn er unnötige Duplikate enthält.
Im folgenden Beispiel sehen Sie das DRY-Prinzip des sauberen Codes deutlicher: Angenommen, der Benutzername und das Kennwort erscheinen zweimal im Code, um in verschiedenen Aktionen verwendet zu werden. Anstatt sie separat zu programmieren, können beide Prozesse zu einer einzigen Funktion zusammengefasst werden . Auf diese Weise wird der WET-Code (? Wet?) Mit seinen Redundanzen zu DRY-Code (? Dry?).
WET-Code:
//Variante A let username = getUserName(); let password= getPassword(); let user = { username, password}; client.post(user).then(/*Variante A*/); //Variante B let username = getUserName(); let password= getPassword(); let user = { username, password}; client.get(user).then(/*Variante B*/);
TROCKENER Code:
function getUser(){ return { user:getUserName(); password:getPassword(); } } //Variante A client.post(getUser()).then(/*Variante A*/ ); //Variante B client.get(getUser()).then(/*Variante B*/);
Beseitigen Sie das Unnötige: YAGNI
Das YAGNI Prinzip ( y ou a ren T? G onna n eed i t o Sie müssen es nicht?) Von sauberen Code auf der folgenden Idee basiert: Entwickler sollten nur Funktionen hinzufügen , um Code notwendig , wenn streng . YAGNI ist eng mit agilen Softwareentwicklungsmethoden verbunden. In Übereinstimmung mit diesem Prinzip wird die Softwarearchitektur schrittweise entwickelt, anstatt von einem allgemeinen Konzept aus zu programmieren , um dynamisch auf jedes Problem reagieren zu können. Mit anderen Worten, sauberer Code wird erstellt, wenn die zugrunde liegenden Probleme so effizient wie möglich gelöst werden .
Lesbar statt prägnant
Der Code muss nicht nur funktionieren und von dem Computer interpretiert werden, auf dem er ausgeführt wird, sondern er muss auch für andere Entwickler verständlich sein , insbesondere wenn er an Verbundprojekten arbeitet. Daher ist im Bereich der Softwareentwicklung die Lesbarkeit des Codes immer wichtiger als seine Prägnanz: Es macht keinen Sinn, prägnanten Code zu schreiben, wenn andere Entwickler ihn nicht verstehen. Ein gutes Beispiel für die Erstellung von lesbarem Code wäre die Benennung von Variablen.
Die Variablennamen sollten immer verständlich sein. Beispielsweise ist es nicht möglich, die folgende Variable ohne eine Erklärung oder weitere Informationen zu verstehen:
int d;
Unter dem folgenden Namen ist dieselbe Variable jedoch selbsterklärend:
int elapsedTimeinDays;
