0. Überblick
Wenn wir Code schreiben, gibt es einige grundlegende Prinzipien, die wir befolgen müssen.
Natürlich müssen wir sie nicht unbedingt befolgen, aber wenn wir die oben genannten Prinzipien beim Schreiben von Code einhalten, gibt es viele Vorteile.
Diese Prinzipien machen den Code leichter lesbar und wartbar. Im Folgenden werden einige wichtige Prinzipien für das Schreiben von Code vorgestellt.
1. Entwicklungsprinzipien, die man sich merken sollte
1.1. DRY (Don't Repeat Yourself)
Das DRY (Don’t Repeat Yourself)-Prinzip bedeutet, Wiederholungen im Code zu vermeiden.
Anstatt dieselbe Funktionalität oder Information an mehreren Stellen zu wiederholen, sollten Sie diese Funktionalität oder Information an einem einzigen Ort verwalten.
Wiederholter Code kann leicht Fehler verursachen und die Wartung erschweren. Wenn Sie beispielsweise denselben Code für dieselbe Funktionalität auf verschiedene Weise geschrieben haben, müssen Sie den Code in Situationen, in denen Änderungen erforderlich sind, genauso oft ändern.
1.2. KISS (Keep It Simple, Stupid)
Das KISS (Keep It Simple, Stupid)-Prinzip bedeutet, den Code so einfach wie möglich zu halten.
Einfacher und klarer Code ist leichter zu verstehen und Fehler zu finden als komplexer Code. Komplexität kann den Prozess der Problemlösung erschweren.
Die Lesbarkeit und Wartbarkeit des Codes sind eng miteinander verbunden. Ein Code mit geringer Länge und Lesbarkeit erschwert das Auffinden von Fehlern oder zu bearbeitenden Teilen.
Insbesondere der häufigste Fehler, den Junior-Entwickler machen, ist das Schreiben von Code, der nur für sie selbst leicht verständlich ist, was oft zu Überstunden für andere Teammitglieder führt.
2. Grundprinzipien für Variablen, Funktionen und Module
2.1. Verwendung von aussagekräftigen Variablen- und Funktionsnamen
Benennen Sie Variablen und Funktionen klar und aussagekräftig. Wenn Sie oder andere Entwickler Ihren Code lesen, wird es einfacher, zu verstehen, was Variablen oder Funktionen tun.
Um möglichst intuitiv und prägnant zu coden, sollten alle Variablen und Funktionen eine Bedeutung enthalten. Sinnlose Funktions- und Variablennamen sind der größte Produktivitätskiller, da sie das Verstehen der Funktion erschweren.
2.2. Verwendung kleiner Funktionen und Module
Versuchen Sie, Funktionen und Module so klein wie möglich zu halten. Eine Funktion sollte nur eine Aufgabe erfüllen, und ein Modul sollte verwandte Funktionen gruppieren.
Das Problem großer Funktionen und Module ist, dass sie relativ unflexibel sind. Kleine Funktionen und Module erleichtern das Wiederverwenden von Code und können dazu beitragen, die Codierzeit bei zunehmender Entwicklungsgröße erheblich zu verkürzen.
3. Prinzipien für Abschluss wichtiger als Beginn
3.1. Unit-Tests und testgetriebene Entwicklung (TDD)
Schreiben Sie beim Codieren Unit-Tests und folgen Sie dem Prinzip der testgetriebenen Entwicklung (TDD, Test-driven development). Tests überprüfen die Funktionsweise des Codes und helfen dabei, Fehler zu finden.
Wenn Sie TDD verwenden, kann die Entwicklungsgeschwindigkeit beeinträchtigt werden, da Sie Tests zusammen mit der Entwicklung schreiben. Es ist wichtig, flexibel zu sein und zu entscheiden, was für Ihr Projekt am besten geeignet ist.
3.2. Fehlerbehandlung
Achten Sie darauf, die Fehlerbehandlung sorgfältig zu schreiben. Wenn Sie entwickeln, müssen Sie immer Code schreiben, der Ausnahmesituationen vorhersehen und behandeln kann.
In robust funktionierenden Programmen ist die Fehlerbehandlung oft gut vorbereitet, um auf verschiedene Szenarien reagieren zu können. Letztendlich gibt es Fälle, in denen das Programm unerwartet aufgrund von Bedingungen funktioniert, die nicht beabsichtigt waren. Daher ist es wichtig, bereits in der Entwicklungsplanungsphase zu wissen, welche Fehlerbehandlungen insgesamt erforderlich sind.
3.3. Code-Überprüfung
Code-Überprüfung ist ein wichtiges Lernwerkzeug. Lesen Sie den Code anderer Entwickler, geben Sie Feedback und erhalten Sie Feedback. Wenn Sie den Code aus der Perspektive einer anderen Person betrachten, können Sie Fehler oder Verbesserungsmöglichkeiten finden.
Wenn Sie niemanden haben, mit dem Sie den Code überprüfen können, ist die Verwendung von TDD als Alternative zur Selbstcode-Überprüfung eine Option, die Sie in Betracht ziehen sollten.
4. Prinzipien für die Entwicklung im Team
4.1. Angemessene Verwendung von Kommentaren
Verwenden Sie Kommentare, um Erklärungen im Code zu hinterlassen. Kommentare, die erklären, was der Code tut und warum er so geschrieben wurde, sind in der Praxis, in der die Entwicklung im Team stattfindet, sehr hilfreich.
Häufige Kommentare machen es genauso schwierig, wie es schwierig ist, mit dem Code selbst zu überzeugen. Es ist am besten, die Kommentare zu minimieren und sich darum zu bemühen, dass der Code selbst erklärend ist.
4.2. Einhaltung von Code-Style-Guides
Befolgen Sie die Code-Style-Guides für Ihr Projektteam oder Ihre Sprache. Eine konsistente Code-Style-Einhaltung erleichtert die Zusammenarbeit und verbessert die Lesbarkeit des Codes.
Das Festlegen des gleichen Code-Stils kann manchmal unnötig und ineffizient erscheinen. Dennoch ist es wichtig, dass jeder in einem Team den Code verstehen und bearbeiten/nutzen kann.
Insbesondere wenn Sie einem bereits laufenden Projekt beitreten, ist es unerlässlich, sich mit dem bestehenden Code-Stil vertraut zu machen und die Richtlinien zu befolgen.
5. Prinzipien zur Verbesserung der Fähigkeiten
5.1. Investition in Selbstentwicklung
Die Entwicklung der Programmierfähigkeiten beschleunigt sich immer mehr. Um damit Schritt zu halten, ist kontinuierliches Lernen und Anstrengung erforderlich. Unabhängig von Ihrer Erfahrung ist es unerlässlich, in das Erlernen neuer Technologien und Werkzeuge zu investieren, um Ihre Fähigkeiten zu verbessern.
5.2. Überwachung von Trends und Austausch zwischen Fachleuten
Um nicht den Anschluss an Trends wie GitHub, Reddit, Hacker News usw. zu verlieren, ist ein kontinuierliches Monitoring und Interesse an Strömungen erforderlich.
Es ist hilfreich, das Ego beiseite zu legen und anstatt die Qualität Ihrer eigenen Werke zu verbessern, schnell auf den Markt zu kommen und Feedback von Experten verschiedener Bereiche zu erhalten, was ebenfalls dazu beiträgt, die Fähigkeiten zu verbessern.
6. Fazit
Das Schreiben von Code ist eine Kombination aus Kunst und Wissenschaft. Es mag am Anfang schwierig sein, aber wenn Sie Erfahrung sammeln und die oben genannten Prinzipien befolgen, können Sie zu einem besseren Programmierer heranwachsen. Fehler und Bugs sind Teil des Lernprozesses, und Sie werden sich kontinuierlich verbessern und besseren Code schreiben.
Lesen Sie auch:
Daten sammeln, jetzt automatisieren
Starten Sie in 5 Minuten ohne Codierung · Erfahrung mit dem Crawlen von über 5.000 Websites
