Namen werden überall im Code benötigt. Als Programmierer müssen wir Klassen, Variablen, Funktionen, Parameter, Namespaces und so weiter benennen. Hier sind 20 Tipps, die Ihnen helfen, Ihre Benennungsfähigkeit zu verbessern.

1. Verwenden Sie Namen, die die Absicht offenbaren

Ein Name sollte uns sagen, was er tut, warum er existiert und wie er funktioniert. Namen zu wählen, die die Absicht offenbaren, macht es uns leichter, den Code zu verstehen.

int d; // elapsed time in days

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

Im obigen Snippet können wir nur aus dem Kommentar erkennen, worauf sich die Variable d bezieht. Leser des Codes müssen daher nach ihren Instanzen suchen, um Hinweise zu erhalten. Wenn wir diese Variable also gut benennen, können Leser sofort wissen, was sie bedeutet.

2. Scheuen Sie sich nicht, Zeit für die Auswahl von Namen aufzuwenden

Sie sollten mehrere verschiedene Namen ausprobieren, bis sie die Bedeutung angemessen beschreiben, und nie zögern, Zeit dafür aufzuwenden. Wer Ihren Code später liest (einschließlich Sie selbst), wird davon profitieren. Darüber hinaus kann ein beschreibender Name Ihnen sogar helfen, das Design eines Moduls in Ihrem Kopf zu klären. Gute Benennung braucht zwar Zeit, aber langfristig überwiegen die Vorteile die Kosten.

3. Namen refaktorisieren

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

4. Vermeiden Sie Füllwörter in Namen

Zum Beispiel,Manager、Processor、Data、Infound Synonyme von „Ich weiß nicht, wie das genannt wird“ sind Füllwörter. Wenn Sie diese Füllwörter verwenden müssen, bedeutet das, dass Ihre Benennung wahrscheinlich zu wortreich ist.

5. Seien Sie vorsichtig 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 nicht gründlich genug und müssen zuerst weitere Informationen sammeln.

6. Klassennamen

Klassen sollten als Namen ein Substantiv oder eine Substantivphrase haben, wie z. B.Customer、WikiPage、AccountundAddressParserSuperklassen sollten kurze, prägnante Namen haben. Unterklassen sollten längere Namen haben 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. Sie leiten sich meist von der Klasse ab, auf die sie verweisen. Boolesche Variablen sollten in Prädikatform geschrieben werden, wie z. B.isEmptyundisTerminateddamit sie in if-Anweisungen leichter zu verstehen sind.

8. Methodennamen

Methodennamen sollten ein Verb oder eine Verbphrase sein, wie z. B.postPayment()、deletePage()undsave()Accessoren und Mutatoren sollten jeweils mit get und set als Präfix versehen werden. Methoden, die einen booleschen Wert zurückgeben, sollten mit 'is' als Präfix versehen werden, wie isPostable(), damit sie in if-Anweisungen leichter zu verstehen sind.

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

Die Länge eines Variablennamens sollte zu seinem Gültigkeitsbereich passen. Ist der Gültigkeitsbereich kurz, sollte auch der Variablenname kurz sein. Umgekehrt sollte der Variablenname länger und beschreibender sein.

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

Die Länge von Methoden- und Klassennamen sollte umgekehrt proportional zu ihrem Gültigkeitsbereich sein. Für öffentliche Methoden sind kürzere Namen besser, weil sie häufig 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 stärker eine Klasse abgeleitet 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 bei äquivalenten Methoden in verschiedenen Klassen,get()、fetch()andretrieve()würde das Ändern des Wortes Menschen verwirren.

12. Verwenden Sie nicht dasselbe Wort für zwei verschiedene Konzepte

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

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

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 musst du dem Namen vielleicht ein Präfix voranstellen, um Kontext hinzuzufügen. Angenommen, wir haben einige Variablen, die eine Adresse darstellen:firstName、lastName、street、houseNumber、city、stateundzipWenn wir nur die state-Variable betrachten, ist es schwierig abzuleiten, worauf sie sich bezieht. Eine bessere Lösung ist es, diese Variablen in einer Address-Klasse zu kapseln.

16. Füge keinen überflüssigen 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. Vermeide Kodierung

Angesichts der Leistungsfähigkeit moderner IDEs müssen wir Typ- und Bereichsinformationen nicht mehr in Variablen- und Klassennamen kodieren. Das schließt ein, dass wir Schnittstellen kein 'I' voranstellen müssen, denn Nutzer des Codes müssen nicht wissen, dass ihre Klassen an eine Schnittstelle übergeben werden. Wenn Sie also unbedingt Kodierung verwenden müssen, ist es besser, Implementierungen statt Schnittstellen zu kodieren.

18. Vermeiden Sie irreführende Informationen

Geben Sie keine falschen Informationen, denn das wird Leser des Codes irreführen. Wenn Sie eine Variable, die tatsächlich ein Array enthält, accountList nennen, können Leser leicht die falsche Schlussfolgerung ziehen.

19. Verwenden Sie unaussprechbare Namen

Programmieren ist eine soziale Aktivität. Die Verwendung unaussprechbarer Namen behindert nur unsere Diskussion.

20. Verwenden Sie durchsuchbare Namen

Kurze, generische Namen machen es schwierig, in der Codebasis nach Dingen zu suchen. Das hat großen Einfluss auf die Bearbeitung und das Refactoring von Code.

Wenn Sie schließlich andere Meinungen haben, zögern Sie bitte nicht, sie mitzuteilen.

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