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

Récemment, en commençant mon premier travail en tant que développeur de logiciels, j'ai été un peu étonné 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 a suivi 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 d'importance particulière. C'était le dernier de mes soucis, alors j'ai juste pris cette convention existante et j'ai couru avec.

int nTickCount  
bool bConnected  
object[] m_aItems  
fSum += fWeight * fValue  
class 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 , cela semble plutôt laid. De plus, avoir chaque classe et fichier dans le projet appelé cSomething semble assez idiot.

Je ne pense pas que ce soit un 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 semble valoir le coup.

Selon vous, quelle est la convention de dénomination la plus élégante et la plus efficace, si une seule doit être utilisée? Indique-t-il le type et / ou la portée?

Joel Spolsky a écrit un article expliquant pourquoi la notation hongroise existe et ce à quoi elle était destinée qui pourrait 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 provient du contexte ou de vos outils de développement dans ces cas. Quelque chose comme imp pour les mesures impériales et rencontré pour la métrique est beaucoup plus logique car sinon vous ne pouvez voir que ce sont des nombres à virgule flottante.

area = width * height

semble parfaitement bien

impArea = metWidth * impHeight

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

Personnellement, j'utilise simplement des noms de variables descriptives. $ 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 langue et de type sémantique.

Ce que vous décrivez s'appelle la notation hongroise . C'était autrefois considéré comme la meilleure pratique, mais il est généralement mal vu maintenant.

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

Oui, les préfixes peuvent être utiles, mais j'ai quelques suggestions:

Si toute votre équipe utilise les mêmes conventions, elles deviennent beaucoup plus utiles. Les utiliser vous-même 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 manque 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 en 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.

Fondamentalement, 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.

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 plus important est: utilisez 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 indiquant le type sont assez distrayantes dans la plupart des langues modernes.

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

Mis à part cela, je dirais que votre exemple de code est beaucoup moins lisible en raison du bruit supplémentaire que vous avez ajouté.

Je trouve que, pour la plupart, le guide de style de codage de Google est assez bon. Comme on vous a dit que vous pouvez utiliser n'importe quel style que vous aimez, je pense que vous devriez commencer par le regarder et le choisir.

Préfixer les noms de variables avec des types de données (en particulier les types de données primitifs) augmente le bruit visuel, ainsi que le risque qu'un changement autrement petit devienne un changement de nom radical.

Concernant le premier point, "intStudentCount" est-il vraiment plus clair que par exemple "numberOfStudents"? "BillLineItems" 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 problématique, pas la représentation de bas niveau.)

Quant au deuxième point, que se passe-t-il lorsque, par exemple, une sélection prématurée de int est remplacée 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 de scénarios de maintenance réalistes me semble discutable.

Cela peut aussi dépendre de la raison pour laquelle vous préfixez le nom, par opposition à ce que vous préférez.

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 (par exemple), mais j'ai tendance à concevoir des formulaires volumineux d'abord, puis à écrire la plupart du code par la suite.

Avoir un préfixe de bt pour les boutons permet de trouver facilement le bon bouton par la suite, au lieu d'avoir beaucoup de noms confondus.

Je n'utilise cependant 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 le sens, le contexte ou l'unité (qui est l'idée originale derrière la notation hongroise).

À 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 une langue typée statiquement, comme celle que vous utilisez, plus je me sens à l'aise avec le système de type, moins la notation hongroise devient importante. Donc, en Java ou en 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 captureront la plupart des erreurs résultant d'une mauvaise compréhension d'un type.

Les préfixes ont souvent un sens pour les objets, par exemple sous une forme où vous pouvez avoir 20 zones de texte les appelant tous tbSomething cela a du sens.

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 short n'est pas assez gros. Maintenant vous avez:

int shortValue = 0;
//stuff happens

À moins que vous ne changiez également le nom de la variable (plus de risques de casser le code que de changer le type dans ce cas), vous avez maintenant du code confus.

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

int loopCounter = 0;
//stuff happens

Si plus tard cela doit changer en un long: aucun problème.

Il y a peut-être plus d'arguments pour ces conventions dans les langages typés dynamiquement ou ceux sans IDE.

J'ai toujours eu tendance à utiliser une abréviation de 2 à 4 caractères pour le type devant la variable elle-même. Parfois, cela semble fastidieux, mais lorsque vous travaillez avec des types de données ou des situations complexes, cela devient bénéfique. Je pense que cela tombe dans la catégorie inférieure des chameaux.

En regardant votre exemple ci-dessus, il serait légèrement réoutillé 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 se remplit dans le Store DataTable.

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

Moins c'est 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 d'aujourd'hui ont vraiment un outil puissant pour refactoriser (en particulier Java) les variables, les noms de méthode, les classes, etc. L'idée de dire le maximum d'informations avec le moins de caractères est juste démodée.