language agnostic - Les préfixes de type et de portée valent-ils des conventions de dénomination?

Translate

Récemment, en commençant mon premier emploi en tant que développeur de logiciels, j'ai été un peu gêné d'apprendre que je n'avais à suivre aucune convention de dénomination dans mon code. Le code écrit par des groupes travaillant sur d'autres projets plus importants suivait les conventions de dénomination, mais depuis que j'ai été amené à écrire une nouvelle application autonome, le sentiment était que cela n'avait pas particulièrement d'importance. C'était le dernier de mes soucis, alors j'ai juste pris cette convention existante et j'ai couru avec.

int nTickCount  
booléen bConnecté
objet [] m_aItems
fSum + = fPoids * fValeur
classe cManager
enum etSystemStates
etSystemStates eState
cManager.cs

Mais en vaut-il vraiment la peine? J'ai du mal à juger de l'effet net que le fait de suivre ce type de convention de dénomination a sur la compréhension et la détection des erreurs, mais,visuellement, ça a l'air un peu moche. De plus, avoir toutes les classes et tous les fichiers du projet appelés cSomething semble assez absurde.

Je ne suis pas dans l'illusion que c'est un gros problème à distance par rapport à des choses qui font une différence évidente, comme les algorithmes et les architectures que vous utilisez. Mais toute convention qui affecte chaque ligne de code que j'écris me semble utile.

Quelle est selon vous la convention de dénomination la plus élégante et la plus efficace, le cas échéant? Indique-t-il le type et / ou la portée?

This question and all comments follow the "Attribution Required."

Toutes les réponses

Mat
Translate

Joel Spolsky a écritun articleexpliquer pourquoi la notation hongroise existe et à quoi elle était destinée peut aider à répondre à votre question.

Les préfixes comme tbl pour une table de base de données, int pour un entier, etc. ne sont généralement pas utiles - il est trivial de déterminer ce qui est quoi à partir du contexte ou de vos outils de développement dans ces cas. Quelque chose comme imp pour les mesures impériales et métrique pour la métrique a beaucoup plus de sens, sinon vous ne pouvez voir que ce sont des nombres à virgule flottante.

area = width * height

semble parfaitement bien alors

impArea = metWidth * impHeight

vous montre tout de suite que quelque chose ne va pas.

Personnellement, j'utilise simplement des noms de variables descriptifs. $ number_of_items est évidemment un nombre entier. $ input_file_handle, $ is_active et $ encrypted_password ont des types évidents à la fois en termes de type de données de langage et de type sémantique.

La source
Translate

Ce que vous décrivez s'appelleNotation hongroise. Elle était autrefois considérée comme la meilleure pratique, mais elle est généralement mal vue aujourd'hui.

L'article Wikipedia contient une section sur ses avantages et ses inconvénients.

La source
Translate

Oui, préfixespouvezêtre utile, mais j'ai quelques suggestions:

Si toute votre équipe utilise les mêmes conventions, elles deviennent beaucoup plus utiles. Les utiliser seul est moins utile.

Dans les langages fortement typés statiquement, ne copiez pas simplement le type d'une variable. Par exemple, "bSubscribed" est un mauvais nom pour une variable booléenne en C # ou Java, car votre IDE sait déjà de quel type il s'agit. En C par contre, qui n'a pas de type booléen, ce serait une information utile.

En C # et Java, vous pouvez envisager un préfixe pour indiquer qu'un objet peut être nul. Ou qu'une chaîne a été échappée par HTML. Ou qu'il représente une expression régulière ou une instruction SQL. Ou qu'un tableau a été trié. Utilise ton imagination.

En gros, il s'agit de vous demander ce que vous aimeriez qu'un nom de variable vous dise, et cela dépend beaucoup du domaine et de la langue dans laquelle vous travaillez.

La source
Translate

Il existe différents «styles» de convention de dénomination, et la plupart d'entre eux ont une certaine valeur pour rendre le code compréhensible.

Ce qui est FAR le plus important est: utiliser des noms descriptifs pour les variables et les fonctions. Dans votre exemple avec "sum", "weight" et "value", vous voudrez peut-être donner des noms plus significatifs: "totalCost", "lumberWeight", "lumberValuePerOunce" (je fais quelques hypothèses ici)

Je trouve que les conventions comme l'ajout de noms de variables avec un caractère signifiant que le type est assez distrayant dans la plupart des langues modernes.

La source
Marcia Lee
Translate

La plupart des développeurs .NET suivent les directives de conception de Microsoft (http://msdn.microsoft.com/en-us/library/ms229042.aspx), qui est assez similaire à Java (la principale différence est que Microsoft favorise Pascal Case pour les noms de membres, tandis que Java favorise camel Case).

En dehors de cela, je dirais que votre exemple de code est beaucoup moins lisible à cause du bruit supplémentaire que vous avez ajouté.

La source
Translate

Je trouve que, pour la plupart,Guide de style de codage de Googlec'est plutôt bien. Puisqu'on vous a dit que vous pouvez utiliser n'importe quel style que vous aimez, je pense que vous devriez commencer par examiner cela, puis en choisir et en choisir.

La source
August Lee
Translate

Le préfixage des noms de variables avec des types de données (en particulier des types de données primitifs) augmente le bruit visuel, ainsi que le risque qu'un changement autrement minime devienne un changement de nom big-bang.

Concernant le premier point, "intStudentCount" est-il vraiment plus clair que par exemple "numberOfStudents"? "FactureLineItems" ne serait-il pas au moins aussi informatif que "aobjItems". (Le type de données doit concerner la signification des données dans le domaine du problème, pas la représentation de bas niveau.)

Quant au deuxième point, que se passe-t-il lorsqu'une sélection prématurée de int est remplacée par exemple par long ou double? Pire encore, que se passe-t-il lorsqu'une classe concrète est refactorisée en une interface avec plusieurs classes d'implémentation? Toute pratique qui alourdit le fardeau des scénarios d'entretien réalistes me paraît discutable.

La source
Translate

Cela peut aussi dépendre dePourquoivous préfixez le nom, par opposition à ce que vous préfixez.

Par exemple, j'ai tendance à utiliser un préfixe de 1 à 2 lettres pour les noms des contrôles sur un formulaire. Ce n'est pas parce que je ne sais pas que le compilateur trouvera facilement la bonne classe pour le bouton (à titre d'exemple), mais j'ai tendance à concevoir d'abord de grands formulaires, puis à écrire la plupart du code par la suite.

Avoir un préfixe debtpour les boutons, il est facile de trouver le bon bouton par la suite, au lieu d'avoir beaucoup de noms mélangés ensemble.

Cependant, je n'utilise pas de préfixes pour nommer les variables, ni pour le type (qui n'est généralement pas très utile de toute façon), ni pour la signification, le contexte ou l'unité (qui est l'idée originale de la notation hongroise).

La source
Miranda Lee
Translate

À mon avis, cela dépend de la langue et de la taille du projet. Je ne suis jamais allé jusqu'à utiliser des préfixes de type sur toutes mes variables, mais vous voulez les nommer de manière claire.

Dans un langage à typage statique, comme celui que vous utilisez, plus je me sens à l'aise avec le système de typage, moins la notation hongroise devient importante. Donc en Java ou C # et en particulier en Haskell, je ne penserais même pas à ajouter ces préfixes, car vos outils peuvent vous indiquer le type d'une expression donnée et attraperont la plupart des erreurs résultant d'une mauvaise compréhension d'un type.

La source
Translate

Les préfixes ont souvent un sens pour les objets, par exemple dans un formulaire où vous pourriez avoir 20 zones de texte les appelant toustbSomethinglogique.

Cependant, la plupart du temps, je ne pense pas que cela en vaille la peine, en particulier pour les types de valeur.

Par exemple, supposons que vous ayez:

short shortValue = 0;
//stuff happens

Des mois plus tard, vous constatez que vous devez le changer - un court métrage n'est pas assez grand. Maintenant vous avez:

int shortValue = 0;
//stuff happens

À moins que vous ne changiez également maintenant le nom de la variable (plus de risque de casser le code que de changer le type dans ce cas), vous avez maintenant un code déroutant.

Il vaut mieux avoir un nom qui décrit ce qu'il contient:

int loopCounter = 0;
//stuff happens

Si plus tard, cela doit changer à long: pas de problème.

Il y a peut-être plus d'arguments pour ces conventions dans les langages à typage dynamique ou ceux sans IDE.

La source
Translate

J'ai toujours été enclin à utiliser une abréviation de 2 à 4 caractères pour le type devant la variable elle-même. Cela semble parfois fastidieux, mais lorsque vous travaillez avec des types de données ou des situations complexes, cela devient bénéfique. Je pense qu'il appartient à la catégorie inférieure des cas de chameau.

En regardant votre exemple ci-dessus, il serait légèrement réorganisé pour être:

int intTickCount;
bool boolConnected;
object [] aobjItems;

Les tableaux ont toujours un a devant le type pour désigner le tableau. Cela me permet également de regrouper des instances de variables similaires. Par exemple, je peux utiliser ...

taStore.Fill(dtStore);

... qui indique que mon Store TableAdapter remplit le Store DataTable.

La source
Translate

J'ai toujours essayé d'adhérer au principe de base selon lequel les préfixes et / ou les suffixes ne devraient être insérés que lorsque cela rend le code plus lisible (comme en anglais ordinaire).

Le moins cryptique, mieux c'est ...

Pourquoi avoir une méthode comme celle-ci:

public boolean connect( String h, int p );

Quand vous pouvez avoir quelque chose comme ça:

public boolean connect( String hostName, int port );

De plus, les IDE ont aujourd'hui vraiment un outil puissant pour refactoriser (surtout Java) les variables, les noms de méthodes, les classes, etc ... L'idée de dire le maximum d'informations avec le moins de caractères est juste démodée.

La source