Namen werden überall im Code benötigt. Als Programmierer müssen wir Klassen, Variablen, Funktionen, Parameter, Namensräume und so weiter benennen. Hier sind 20 Tipps, die dir helfen, deine Benennungsfähigkeiten zu verbessern.

1. Verwende Namen, die die Absicht ausdrücken

Namen sollten uns sagen, was etwas tut, warum es existiert und wie es funktioniert. Wenn wir absichtsvermittelnde Namen wählen, wird es für uns einfacher, den Code zu verstehen.

int d; // elapsed time in days

int elapsedTimeInDays;
int daysSinceCreation;
int daysSinceModification;
int fileAgeInDays;

Im obigen Ausschnitt können wir nur aus dem Kommentar erkennen, worauf sich die Variable d bezieht. Daher müssen Leser des Codes nach ihren Instanzen suchen, um Hinweise zu erhalten und ihre Bedeutung zu verstehen. Wenn wir diese Variable also gut benennen, werden Leser des Codes ihre Bedeutung sofort erkennen.

2. Scheue dich nicht davor, Zeit für die Auswahl von Namen aufzuwenden

Du solltest mehrere verschiedene Namen ausprobieren, bis sie ihre Bedeutung ausreichend beschreiben, und niemals Angst davor haben, Zeit dafür aufzuwenden. Diejenigen, die deinen Code später lesen (einschließlich deiner selbst), werden davon profitieren. Darüber hinaus kann ein beschreibender Name dir sogar helfen, das Design des Moduls in deinem Kopf zu klären. Gute Benennung braucht Zeit, aber auf lange Sicht überwiegen die Vorteile die Kosten.

3. Namen refaktorisieren

Wenn Ihnen später in der Entwicklung ein besserer Name einfällt, zögern Sie nicht – ändern Sie ihn einfach. Die heutigen IDEs machen das Umbenennen extrem einfach.

4. Vermeiden Sie Füllwörter in Namen

Zum Beispiel,Manager、Processor、Data、Infound Synonyme von "Ich weiß nicht, wie ich das nennen soll" sind alles Füllwörter. Wenn Sie diese Füllwörter verwenden müssen, bedeutet das, dass Ihre Namensgebung möglicherweise zu redundant ist.

5. Vorsicht bei Klassen/Funktionen, die schwer zu benennen sind

Eine Klasse oder Funktion, die schwer zu benennen ist, ist wahrscheinlich ein Code Smell. Sie deutet auf Folgendes hin:

• Der Code macht zu viel.
• Der Code macht zu wenig.
• Sie verstehen das Problem noch nicht gut genug und müssen weitere Informationen sammeln.

6. Klassennamen

Klassen sollten Namen haben, die Substantive oder Substantivphrasen sind, wie z. B.Customer、WikiPage、AccountundAddressParserSuperklassen in der Vererbung sollten kurze, prägnante Namen erhalten. Namen von Unterklassen sollten länger sein und Adjektive verwenden, um zu beschreiben, wie sie sich von ihrer Superklasse unterscheiden, wie z. B.SavingsAccountvon Account abgeleitet.

7. Variablennamen

Variablennamen sollten ebenfalls Substantive sein. Die meisten leiten sich von der Klasse ab, auf die sie sich beziehen. Boolesche Variablen sollten als Prädikate geschrieben werden, wie z. B.isEmptyundisTerminated, was sie in if-Anweisungen leichter verständlich macht.

8. Methodennamen

Methodennamen sollten ein Verb oder eine Verbphrase sein, wie z. B.postPayment()、deletePage()undsave()Accessor- und Mutator-Methoden sollten jeweils die Präfixe get bzw. set erhalten. Methoden, die boolesche Werte zurückgeben, sollten mit 'is' als Präfix versehen werden, wie z. B. isPostable(), damit sie in if-Anweisungen leicht verständlich sind.

9. Gültigkeitsbereichsgröße und Länge von Variablennamen

Die Länge eines Variablennamens sollte zur Größe seines Gültigkeitsbereichs passen. Wenn die Variable einen kleinen Gültigkeitsbereich hat, sollte ihr Name kurz sein. Umgekehrt sollte der Name länger und aussagekräftiger sein.

10. Gültigkeitsbereichsgröße und Länge von Methoden-/Klassennamen

Bei Methoden und Klassen sollte die Namenslänge jedoch umgekehrt proportional zum Gültigkeitsbereich sein. Bei öffentlichen Methoden sind kürzere Namen besser, weil sie viele Male aufgerufen werden. Private Methoden werden nur innerhalb der Klasse aufgerufen, daher können längere Namen als Dokumentation dienen. Die Ausnahme von dieser Regel sind Namen abgeleiteter Klassen. Je abgeleiteter eine Klasse ist, desto mehr Adjektive werden vor die Basisklasse gesetzt, und desto länger wird der Name.

11. Ein Konzept, ein Wort

Wählen Sie ein Wort für ein abstraktes Konzept und ändern Sie es dann nicht mehr. Zum Beispiel als äquivalente Methoden in verschiedenen Klassen,get()、fetch()andretrieve()kann verwirrend sein. Konsistente Vokabeln sind ein wichtiges Werkzeug für Programmierer, um Code zu verwalten.

12. Verwende nicht dasselbe Wort für zwei verschiedene Konzepte

Wenn du Punkt 11 befolgst – das Prinzip ein Konzept, ein Wort – kannst du viele Klassen mit demselben Methodennamen vermeiden. Solange die Parameterlisten und Rückgabewerte der verschiedenen Methoden semantisch äquivalent sind, gibt es kein Problem. Probleme entstehen nur, wenn du dasselbe Wort für zwei verschiedene Konzepte verwendest.

Zum Beispiel können wiradd()Methode in mehreren Klassen verwenden, um einen neuen Wert zu erzeugen, indem wir zwei vorhandene Werte addieren oder verketten. Wenn wir später in einer Klasse eine add-Methode einführen müssen, um einer Sammlung einen Parameter hinzuzufügen, verursacht dies Probleme aufgrund unterschiedlicher Semantik. Es wäre besser, diese neue Methode in insert() umzubenennen.

13. Verwende Namen aus der Lösungsdomäne

15. Füge aussagekräftigen Kontext hinzu

Die meisten Namen sind für sich genommen bedeutungslos und müssen in einen Kontext (Klasse/Funktion/Namespace) gestellt werden, damit Leser verstehen, worauf sie sich beziehen. In manchen Fällen kann es notwendig sein, Namen mit einem Präfix zu versehen, um Kontext hinzuzufügen. Angenommen, wir haben einige Variablen, die eine Adresse darstellen:firstName、lastName、street、houseNumber、city、stateundzip. Wenn wir nur die Variable state betrachten, ist es schwierig abzuleiten, was sie bedeutet. Eine bessere Lösung ist, diese Variablen in einer Address-Klasse zu kapseln.

16. Fügen Sie keinen unnötigen Kontext hinzu

Solange die Bedeutung klar ist, sind kürzere Namen normalerweise besser als längere, also fügen Sie keinen unnötigen Kontext hinzu. Namen sollten nicht mit unnötigen Informationen versehen werden, die aus der Klasse/dem Paket/Namespace abgeleitet werden können.

17. Vermeiden Sie Kodierung

Angesichts der Leistungsfähigkeit heutiger IDEs müssen wir Typ- und Bereichsinformationen nicht mehr in Variablennamen und Klassennamen kodieren. Dazu gehört, dass wir Schnittstellen kein 'I' voranstellen müssen, weil Nutzer des Codes nicht wissen müssen, dass ihre Klasse an eine Schnittstelle übergeben wird. Wenn Sie also Kodierung verwenden müssen, ist es besser, die Implementierung statt der Schnittstelle zu kodieren.

18. Vermeiden Sie irreführende Informationen

Geben Sie keine irreführenden Informationen, weil sie die Leser des Codes in die Irre führen. Wenn Sie eine Variable, die tatsächlich ein Array enthält, accountList nennen, können Leute leicht falsche Schlussfolgerungen ziehen.

19. Vermeiden Sie unaussprechbare Namen

Programmieren ist eine soziale Aktivität; die Verwendung unaussprechbarer Namen behindert nur unsere Diskussionen.

20. Verwenden Sie leicht suchbare Namen

Die Verwendung kurzer, generischer Namen macht es schwierig, Dinge in der Codebasis zu suchen. Dies hat großen Einfluss auf unsere Fähigkeit, den Code zu manipulieren und zu refaktorisieren.

Zum Schluss: Wenn Sie anderer Meinung sind, teilen Sie diese bitte gerne mit.

Quelle: http://www.codeceo.com/article/20-naming-tips-programmer-know.html