it-swarm-fr.com

Les identificateurs courts sont-ils mauvais?

Les identificateurs courts sont-ils mauvais? Comment la longueur de l'identifiant est-elle corrélée à la compréhension du code? Quels autres facteurs (en plus de la compréhension du code) pourraient être examinés en matière d'identificateurs de nommage?

Juste pour essayer de conserver la qualité des réponses, veuillez noter qu'il y a certains Recherche sur le sujet déjà!

Edit

Curieux que tout le monde ne pense pas que la longueur soit pertinent ou a tendance à préférer des identifiants plus importants, lorsque les deux liens que j'ai fournis indiquent que les grands identifiants sont nocifs!

Lien brisé

Le lien ci-dessous a souligné une recherche sur le sujet, mais il est maintenant cassé, je ne semble pas avoir une copie du papier avec moi et je ne me souviens pas de ce que c'était. Je le quitte ici au cas où quelqu'un d'autre la figure.

26
Daniel C. Sobral

La meilleure "règle" que j'ai entendue est que les longueurs de noms devraient être proportionnelles à la longueur de la portée de la variable. Donc, un index i va bien si le corps de la boucle est de quelques lignes de long, mais j'aime utiliser quelque chose d'un peu plus descriptif s'il devient plus long que 15 lignes.

Chaque variable devrait avoir une signification et son nom fait partie de cette signification. Et une partie très importante, car elle aide le lecteur à comprendre ce qu'il est pour ne pas creuser plus profondément dans l'algorithme. i, j _ sont évidents d'être utilisés comme indices, ils sont courts, mais très informatifs. bnt est laid, close ou closeButton sont significatifs. Donc, être court ou long n'est pas le critère le plus important pour le nom de la variable, il devrait être significatif. La signification dépend fortement du contexte. Par exemple, vous pouvez donner un nom très court comme n à la variable de chaîne locale utilisée dans un petit bloc du code indique 10 lignes et fait référence au nom d'une propriété (v Pour la valeur en est un autre exemple).

SO les noms variables doivent être informatifs et il n'a pas d'importance qu'ils courtes ou longs.

48
duros

Je vais utiliser un identifiant décrivant la variable, quelle que soit la longueur.

Les cas de I, J et K sont en eux-mêmes si omniprésents qu'ils décrivent eux-mêmes, vous savez automatiquement qu'ils sont des indices de boucle. Vous pouvez aussi dire la même chose pour:

foreach loop (Strings s : myString)

Cependant, les IDE fournissent désormais des outils d'achèvement de code afin que le seul effet secondaire négatif d'identificateurs très longs et descriptifs a été supprimé AFAIK.

J'ajouterai volontiers un mot d'identifiant, si c'est nécessaire pour expliquer le but de la variable.

13
NimChimpsky

Ils ne sont pas aussi mauvais que les identifiants trompeurs. Cela ne me dérange pas de déboguer du code dans lequel les identificateurs ne sont qu'une lettre, mais le moment où différentes conventions de nommage entrent dans la photo, elle devient gênante. E.G., si quelque part que vous voyez strPersonID, puis quelque part ailleurs que vous voyez s_EmployeeID, alors il est déroutant de dire si ces deux cordes sont-elles à la fois et s'il existe une différence. Aussi si les variables sont collées (pmapIntString = new std::map<int,int>) et sont totalement faux, je m'inquiéterai.

En ce qui concerne moi, j'ajoute des commentaires dans le code des variables importantes utilisées et essayez de maintenir la norme donnée dans la directive de développement. S'il n'y a pas de norme, j'essaie de maintenir la même convention de dénomination tout au long du code.

9
Manoj R

Je lutte ...

J'utilise toujours pour toujours utiliser des noms descriptifs comme identifiants, mais en retard, j'ai utilisé des identifiants très courts.

Je pense que cela dépend du contexte du code:

  • Si vos fonctions complexes d'écriture (algorithmes), utilisez toujours des identificateurs courts (les caractères simples sont les meilleurs)
  • Lorsque vous écrivez des valeurs de paramètre pour les fonctions, utilisez des noms descriptifs.

Je suppose que cela dépend également de la dense du code. Parfois, avoir des noms le rend plus difficile à lire.

Parfois, sans nommer son totalement cryptique!

5
Darknight

Ma pensée est qu'ils ne sont pas mauvais en eux-mêmes, mais ils sont insuninformatifs à moins qu'ils ne soient très standards.

Donc, des variables en boucle étant i, j et k est si standard qu'il n'y a aucune raison de ne pas les utiliser si vous créez une boucle indexée.

L'autre endroit où j'utiliserai un identifiant très court est lorsque je déclare une variable temporaire qui s'étraînera dans quelques lignes dans quelques lignes, la variable temporaire d'une boucle foreach, par exemple. Si cela ne sera pas appelé nulle part ailleurs, il est facile de lire le code de voir la déclaration et de suivre ce qu'il est utilisé. Si cela va être utilisé pendant plus de cinq ou six lignes, je chercherai à lui donner un nom plus clair.

Au-delà de cela, j'essaie d'utiliser des identifiants de longueur informatif - en particulier à un niveau de classe, je souhaite un identifiant que vous pouvez lire et avoir une idée de la variable de la variable. S'ils deviennent trop longs (et que je vois du code parfois avec quatre ou cinq mots enfilés pour un identifiant), j'ai tendance à considérer cela comme une odeur de code - si j'ai besoin de beaucoup de texte pour distinguer mes variables sont-elles en réalité un groupe qui pourrait être mieux stocké dans un hashmap ou une liste? Pourrais-je créer une sorte d'objet pour modéliser ces données plus précisément? Parfois, vous ne pouvez qu'un très long identifiant est un indicateur qu'il y a quelque chose qui vaut la peine d'être regardé ici.

3
glenatron

Je suis très d'accord avec les autres réponses ici, mais je voudrais souligner un autre facteur que je pense est souvent négligé. Un bon nom est souvent celui qui est idiomatique au code. Cela peut être sur un niveau de langue, un niveau d'algorithme ou des idiomes internes pour la base de code. Le point est que bien que le nom ne signifierait rien à quelqu'un qui ne connaît pas le domaine du code, il peut toujours être le meilleur nom dans le contexte donné.

3
harald

Nommer une variable est toujours un exercice pour équilibrer l'unicité et la compréhensibilité. La longueur du nom est liée aux deux, de différentes manières. Les noms plus longs sont plus faciles à faire uniques; Les noms de longueur moyenne ont tendance à être plus compréhensibles que les noms trop courts ou trop longs.

Un nom de variable très court n'est utile que s'il a une histoire qui le rend compréhensible (par exemple, i, j, & k pour les indices; dx pour une distance le long d'un axe) ou une portée suffisamment petite pour que toutes les références soient visibles à la fois (par exemple, temp). Les pires noms de variables dans le monde sont des choses comme t47. ("Qu'est-ce que cela signifie et pourquoi est-ce différent de t46? ") Dieu merci que le style de nommage est sorti avec Fortran, mais c'est là que le désir de noms de variables plus longs est enraciné.

Comme votre papier d'origine montrait, des noms trop longs sont également difficiles à lire, car les différences internes subtiles peuvent être manquées lors de la sauvegarde au code. (La différence entre DistanceBetweenXAxisAbscissae & DistanceBetweenYAxisAbscissae est vraiment difficile à ramasser rapidement.)

Comme Notetoself a souligné plus tôt, les exigences relatives à l'unicité d'un nom dépendent principalement de la portée du nom. L'index d'une boucle de 5 lignes peut être i; Un index d'un enregistrement actif qui est passé de fonction à la fonction a mieux eu un nom beaucoup plus descriptif.

Une variable locale à une fonction peut avoir un petit nom descriptif comme deltaX sans problème. Une variable de delta x statique dans un module doit avoir un nom qui distingue ce deltax d'un autre Deltax dans le même module, ce qui le rend plus long. Et une variable de Delta X globale doit être faite unique sur tous les modules et tous les autres modules pouvant être créés, probablement en concaténant le nom du module à l'autre nom descriptif. C'est l'un des nombreux problèmes des globaux; Pour être utilement unique, les noms doivent être suffisamment longs pour les rendre difficiles à lire.

3
Erik Johnson

Au contraire, je pense que les identificateurs longs sont pires que les identificateurs courts (à moins que vous ne traitez de constantes). L'utilisation TheVariableThatHoldsTheCapacityOfMyContainerClass rend votre code beaucoup plus sujet aux erreurs que d'utiliser Capacity.

2
Maxpm

En, et d'eux-mêmes, les identificateurs courts ne sont pas mauvais. Le but de choisir de bons noms (courts ou longs) est en service pour coder la clarté. Choisir des identifiants au service de la clarté du code est plus important que de répondre à une exigence de longueur minimale. En général, ce que cela signifie écrit des noms significatifs légèrement plus longs.

2
dietbuddha

Une observation que j'ai eu au fil des ans et que c'est moins aujourd'hui qu'aucun il y a 10 ou 15 ans. Les programmeurs qui ne peuvent pas taper sont ceux qui vous battront des dents et des ongles sur la nommage variable. Ils sont ceux avec tous les noms de variable de 1 à 3 lettres.

Donc, mon conseil est d'utiliser un nom significatif autant de commentateurs ont dit, puis apprenez à taper. J'avais envisagé d'ajouter un test de frappe aux entretiens, juste pour voir où les gens sont, mais je commence à voir beaucoup moins des non-Thouteurs, car les ordinateurs deviennent une partie plus importante de la société.

1
Bill Leeper

Une de mes principales métriques pour déterminer si une ligne de code est lisible ou non est la quantité d'autres contextes d'autres lignes à être lues pour être vraiment sûre de comprendre ce que la ligne fait.

Il est facile de dire que "tout le monde devrait être capable de comprendre que je, j et k sont des variables de boucle". Et la plupart des temps, c'est vraiment évident. Mais j'essaie toujours de rester humble et professionnel à ce sujet et suppose qu'il est facile de faire des erreurs lors de la programmation. Donc, si je suis en boucle à travers un tableau de grobbles, je nommerai la variable de boucle Grobbleindex. Je pourrais aussi accepter i comme une abréviation de l'index. Lorsque vous utilisez I J et K, il est plus difficile de repérer une erreur comme à l'aide de l'index incorrect avec le mauvais tableau et ainsi de suite. Et cela devient encore pire lorsque vous avez une boucle intérieure.

Ps. À l'époque, j'ai écrit cette réponse, je codisons de JavaScript sur un mini ordinateur portable de 10 "avec un écran divisé verticalement dans Vim et j'ai toujours pris le temps de nommer mes variables de boucle Rowindex et ColuminIdex.

1
Sam

Le premier document que vous connaissez un lien avec une apparence intéressante, mais sa conclusion est qu'elles ne trouvaient aucune preuve significative pour ou contre l'hypothèse qui "motivation à la terre", y compris des noms de variables significatifs, aidez à la compréhension du code. Le vent d'occasion habite le temps comme un proxy pour la compréhension de code qui est intéressant, mais pas un Dunk Slam.

J'ai bien peur de trouver le deuxième papier juste idiot. Le premier problème est que les exemples de noms longs qu'ils fournissent sont gratuits et ne fournissent aucune information supplémentaire. Je pense que nous pouvons tous convenir que faire un nom de variable plus longtemps pour la rendre plus longue est stupide. Leur exemple de nommer une variable distance_between_abscreae plutôt que DX est un homme de paille.

Plus important encore, leur expérience est un test de mémorisation simple plutôt que de compréhension. Il teste la capacité des sujets à remplir des morceaux manquants d'un nom de variable lorsqu'il est présenté dans une liste avec NON contexte. Oui, les noms plus longs sont plus difficiles à mémoriser, mais quand je codage, je ne mémorise pas de noms de variables, je les utilise pour fournir un contexte. Je suppose que vous pourriez faire valoir que la difficulté de mémoriser une variable longue variable rend le code plus difficile à écrire, mais le code est lu beaucoup plus souvent qu'il n'est écrit, de sorte que l'activité doit être optimisée?

1
Charles E. Grant

Je pense que l'idéal est que les noms doivent être descriptifs sauf ...

L'idée que les noms peuvent (peut-être devrait) être plus courte - et donc d'impliquer moins descriptives - si elles ont une portée limitée, c'est seulement ne raison de s'écarter de l'idéal.

Personnellement, j'utilise fréquemment des noms courts pour un petit nombre d'entités référencées à plusieurs reprises. On appelle fréquemment des sous-programmes spécifiques aux applications, par exemple.

0
FumbleFingers