Code lesen wie ein Buch: Warum gutes Naming der Schlüssel zu verständlichem Code ist

Eines der grundlegenden Konzepte in der Programmierung ist die Verwendung von Variablen. Variablen sind Namen, die wir einem Wert oder einem Objekt in unserem Code geben. Wir verwenden sie, um Informationen zu speichern, zu manipulieren und darauf zuzugreifen. Ein wichtiger Faktor bei der Verwendung von Variablen ist das Naming, also die Benennung von Variablen. In diesem Artikel werden wir uns genauer damit beschäftigen, warum gutes Naming bei Variablen in der Programmierung so wichtig ist.

Lesbarkeit und Verständlichkeit

Ein guter Variablenname sollte klar und aussagekräftig sein. Ein Name sollte nicht nur den Inhalt der Variable widerspiegeln, sondern auch ihre Bedeutung und ihren Zweck im Kontext des Codes. Wenn wir uns mit unserem Code auseinandersetzen, sollten wir in der Lage sein, schnell zu verstehen, welche Variablen wofür verwendet werden. Wenn Variablen gut benannt sind, können wir Code schneller lesen und verstehen, was die Wartbarkeit unseres Codes verbessert.

Vermeidung von Fehlern

Ein weiterer wichtiger Aspekt beim Naming von Variablen ist die Vermeidung von Fehlern. Wenn wir beispielsweise eine Variable „i“ nennen, könnte dies zu Verwechslungen führen, wenn wir in unserem Code mehrere Schleifen haben. Eine aussagekräftigere Bezeichnung wie „index“ würde dazu beitragen, Fehler zu vermeiden und den Code klarer zu gestalten. Wenn wir unklare oder schlecht benannte Variablen verwenden, kann dies zu Bugs führen, die schwer zu erkennen und zu beheben sind.

Erweiterbarkeit und Wiederverwendbarkeit

Gut benannte Variablen tragen auch zur Erweiterbarkeit und Wiederverwendbarkeit unseres Codes bei. Wenn wir eine Funktion schreiben, die Variablen verwendet, die gut benannt sind, ist es viel einfacher, diese Funktion später wiederzuverwenden oder zu erweitern. Wenn wir dagegen schlecht benannte Variablen verwenden, wird das Verständnis und die Wiederverwendbarkeit unseres Codes beeinträchtigt.

Ein Beispiel dafür wäre eine Funktion, die eine Rechnung erstellt. Wenn wir die Variablen „a“, „b“ und „c“ verwenden, könnte dies zu Verwirrung führen, wenn wir diese Funktion später wiederverwenden oder erweitern möchten. Eine bessere Benennung von Variablen wie „anzahlArtikel“, „preisProArtikel“ und „gesamtSumme“ würde dazu beitragen, die Funktion klarer zu gestalten und ihre Wiederverwendbarkeit zu verbessern.

Einheitlichkeit und Zusammenarbeit

Gutes Naming bei Variablen ist auch wichtig, um die Einheitlichkeit und Zusammenarbeit innerhalb eines Teams sicherzustellen. Wenn jeder Entwickler unterschiedliche Namen für Variablen verwendet, kann dies zu Verwirrung und unlesbarem Code führen. Wenn wir uns auf eine Namenskonvention einigen, erleichtert dies die Zusammenarbeit und das Verständnis des Codes innerhalb des Teams. Ein Beispiel für eine Namenskonvention ist, Variablennamen mit Kleinbuchstaben zu beginnen und den ersten Buchstaben jedes folgenden Worts groß zu schreiben, wie es bei der CamelCase-Konvention der Fall ist.

Namenskonventionen bei Boolean

Eine gängige Konvention ist, dass der Name der Variable ein Verb enthält, das beschreibt, was der Boolean bedeutet. Wenn beispielsweise ein Boolean verwendet wird, um anzuzeigen, ob ein Benutzer eingeloggt ist oder nicht, könnte der Name der Variable „isLoggedIn“ sein.

Eine andere Konvention ist, dass der Name der Variablen mit „is“ oder „has“ beginnt, um anzuzeigen, dass es sich um einen Boolean handelt. Beispiele für solche Variablennamen sind „isEnabled“, „hasPermission“ oder „isComplete“.

Es gibt auch eine spezielle Konvention für Boolean-Variablen, die oft in Java-Code verwendet wird und als „PascalCase“ bezeichnet wird. Bei dieser Konvention beginnt der Name der Variablen mit einem Großbuchstaben, gefolgt von einem Verb in der Vergangenheitsform. Ein Beispiel wäre „LoggedIn“ oder „Enabled“.

Linter-Konfigurationsdatei

Ein Linter ist ein Tool, das den Code analysiert und auf Fehler oder inkonsistente Formatierung hinweist, um sicherzustellen, dass der Code den Konventionen und Standards entspricht. Hier ist ein Beispiel für eine Linter-Konfiguration mit der Erweiterung ESLint für JavaScript/TypeScript:

{
  "rules": {
    "camelcase": ["error", {"properties": "never", "ignoreDestructuring": true}],
    "consistent-this": ["error", "self"],
    "no-shadow": "error",
    "no-underscore-dangle": ["error", {"allowAfterThis": true}]
  }
}

In diesem Beispiel verwenden wir vier Regeln:

1. camelcase: Dies stellt sicher, dass Variablen, Funktionen und Parameter in der CamelCase-Schreibweise benannt sind. Die Option „properties“: „never“ stellt sicher, dass auch Eigenschaften von Objekten in CamelCase geschrieben werden. Die Option „ignoreDestructuring“: true stellt sicher, dass Destructuring-Zuweisungen ignoriert werden, da diese oft mit Unterstrichen geschrieben werden.
2. consistent-this: Dies stellt sicher, dass das this-Keyword in der Schreibweise „self“ verwendet wird.
3. no-shadow: Dies stellt sicher, dass keine Variablen in einer inneren Funktion definiert werden, die den Namen einer Variablen aus der äußeren Funktion hat.
4. no-underscore-dangle: Dies stellt sicher, dass Variablen keine Unterstriche am Anfang oder Ende ihres Namens haben, außer wenn sie mit this. beginnen. Dies wird oft verwendet, um private Variablen zu kennzeichnen.

Diese Linter-Regeln stellen sicher, dass unser Code konsistent und lesbar ist und dass wir gute Naming-Konventionen einhalten. Es gibt viele weitere Regeln, die wir hinzufügen könnten, je nach unseren spezifischen Anforderungen oder Vorlieben. Mit dieser Konfiguration können wir sicherstellen, dass unser Code gut strukturiert und leicht zu warten ist.

Fazit

Zusammenfassend lässt sich sagen, dass gutes Naming in der Programmierung entscheidend für die Lesbarkeit, Wartbarkeit und Verständlichkeit des Codes ist. Variablennamen sollten klar, präzise und aussagekräftig sein, um anderen Entwicklern zu helfen, den Zweck des Codes zu verstehen und Änderungen effektiv vorzunehmen. Es gibt verschiedene Naming-Konventionen, die Entwickler anwenden können, um konsistenten und verständlichen Code zu schreiben. Ein Linter kann helfen, sicherzustellen, dass der Code diesen Konventionen entspricht und somit einen klaren und gut strukturierten Code zu garantieren. Insgesamt ist es wichtig, sich Zeit für die Namensgebung von Variablen zu nehmen, um den Wert des Codes langfristig zu erhöhen.