Est-ce que je sacrifie des noms de variables plus courts pour un code plus long "columné"?
Je suis un programmateur amateur dans une classe CS essayant d'apprendre des compétences de programmation appropriées. Voici comment mon code a l'air, les bords de celui-ci s'étend jusqu'à 103 colonnes.
int extractMessage(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
int lengthOfWord = 0;
int lengthOfCipher = 0;
lengthOfWord = length(keyWord);
lengthOfCipher = length(cipherText);
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset] != cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
continue;
}
}
Avant d'avoir ces noms de variables super longs, j'avais une chose comme moi, J, K, mais mon professeur insiste que nous ne voulons pas utiliser de variables comme celle-ci dans le "monde professionnel" et que même des variables raccourcies comme Lenword sont insuffisants parce que les personnes pourraient supposer que cela représente "la littérature mondiale de Lennard". Il dit de choisir des noms de variables significatifs, mais en le faisant, j'ai l'impression d'avoir brisé la règle d'or du codage pour la garder sous 80 colonnes. Comment puis-je contourner cela?
Normalement, lorsque je vois du code posté ici comme le vôtre, je le modifie, car nous détestons le défilement horizontal. Mais depuis que cela fait partie de votre question, je vous montrerai la modification ici:
int extractMessage(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
int lengthOfWord = 0;
int lengthOfCipher = 0;
lengthOfWord = length(keyWord);
lengthOfCipher = length(cipherText);
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset]
!= cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
continue;
}
}
}
Cette pause peut être surprenante, mais elle est plus lisible que la version avec défilement horizontal, et c'est mieux que de raccourcir les noms de i, j et k.
Ce n'est pas que vous ne devriez jamais utiliser i, j et k. Ce sont des noms fins lors de l'indexation 3 nichées for boucles. Mais ici, les noms sont vraiment mon seul indice sur ce que vous attendiez. Surtout que ce code ne fait rien.
La meilleure règle à suivre sur la longueur de nom variable est la portée. Plus une vie variable est longue, plus son nom de variables doit être conclu avec. Le nom Candiedorange est unique sur la pile Exchange. Si nous étions dans un chat, vous pourriez simplement m'appeler "Candy". Mais en ce moment, vous êtes dans une portée où ce nom pourrait être confondu avec Candide , Candy Chi , ou Candyfloss . Donc, plus la portée est longue, plus le nom devrait être long. Plus la portée est plus courte, le nom plus court peut être.
La longueur de la ligne devrait jamais Dicter la longueur du nom. Si vous avez envie de trouver, vous trouvez une autre façon de définir votre code. Nous avons de nombreux outils pour vous aider à faire cela.
Une des premières choses que je cherche est un bruit inutile de se débarrasser de. Malheureusement, cet exemple ne fait rien, c'est donc tout le bruit inutile. J'ai besoin de quelque chose pour travailler avec donc la première faisons faire quelque chose.
int calcCipherColumn(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
int lengthOfWord = 0;
int lengthOfCipher = 0;
lengthOfWord = length(keyWord);
lengthOfCipher = length(cipherText);
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset]
!= cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
continue;
}
}
return cipherColumn;
}
Là, maintenant ça fait quelque chose.
Maintenant que cela fait quelque chose, je peux voir ce que je peux me débarrasser. Ce truc de longueur n'est même pas utilisé. Ceci continue ne fait rien non plus.
int calcCipherColumn(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset]
!= cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
}
}
return cipherColumn;
}
Faisons quelques ajustements de l'espace blanc mineur, car nous vivons dans un monde de contrôle de la source et c'est bien lorsque la seule raison que la ligne est signalée comme modifiée, c'est parce que cela fait quelque chose de différent, pas parce que une partie de celle-ci a dû aligner dans une colonne.
int calcCipherColumn(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset]
!= cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
}
}
return cipherColumn;
}
Oui, je sais que c'est un peu moins lisible, mais sinon, vous conduirez des gens fous qui utilisent des outils VDiff pour détecter des modifications.
Maintenant, corrigeons ces pauses de lignes idiotes que nous avons parce que nous essayons de rester sous des limites de longueur de ligne.
int calcCipherColumn(
char keyWord[25],
char cipherText[17424],
int rowSize,
char message[388]
) {
int keyColumn = 0;
int keyOffset = 1;
int nextWord = 1;
int cipherColumn = 0;
int cipherOffset = (rowSize * nextWord) + nextWord;
char key = keyWord[keyColumn];
char keyNext = keyWord[keyColumn + keyOffset];
while (key != cipherText[cipherColumn]) {
cipherColumn++;
if (keyNext != cipherText[cipherColumn + cipherOffset]) {
cipherColumn++;
}
}
return cipherColumn;
}
Là, la logique de la boucle est maintenant concentrée sur les changements de la boucle. En fait, tout sauf cipherColumn pourrait être marqué final. Et hey! Regarde ça. Nous avons maintenant de la place pour le faire.
Tout ce que j'ai fait, ajoutez 3 plus variables, renommez-les un et les réorganisez un peu. Et le résultat vient de faire suffisamment de lignes suffisamment courtes pour s'adapter sans files idiotes sur !=.
Assurez-vous que les noms key et keyNext ne sont pas aussi descriptifs, mais ils ne sont utilisés que lorsqu'ils ne vivent pas aussi longtemps, et surtout ne faisant rien de quoi intéressant dans la boucle. Donc, ils n'ont pas besoin d'être. En introduisant des variables supplémentaires, nous avons maintenant de la place pour faire de leur nom si nous avons besoin de. Les choses changent, alors finalement, nous devrions peut-être avoir besoin. Si nous faisons, c'est bien que nous ayons une salle de respiration.
J'ai également pris la liberté de vous montrer Variante de la forme 6 de Jeff Grigg Style de mise en place de paramètres d'entrée pour respecter les restrictions de longueur de ligne.
D'autres ont déjà fait des suggestions utiles, laissez-moi résumer:
- 80 caractères par ligne auraient pu être une règle d'or dans les années 80. De nos jours, la plupart des gens conviennent que 100 à 130 caractères vont bien.
- Utilisez des chevrefeaux dans vos expressions.
- Divisez de longues expressions en introduisant des résultats intermédiaires.
J'aime ajouter une autre recommandation: ( Ne soyez pas dogmatique sur les noms longs! Plus l'étendue d'une variable est, Plus les informations doivent être apportées à son nom. Et généralement, il est une bonne idée de garder la portée des variables petites.
Par exemple, si vous avez une variable pour la colonne de votre table de cryptage de mot-clé et qu'il est clair qu'il n'ya qu'une table utilisée dans la portée de votre variable, il convient de l'appeler column ou même col. Si la portée est plus grande et que de multiples tables sont impliquées, il est logique de l'appeler keyWordEncryptionTableColumn.
Un autre exemple: si vous avez une boucle avec un corps couvrant deux ou trois lignes et devez utiliser un index pour accéder aux éléments d'un tableau, il n'y a rien de mal à appeler l'index i. Dans ce contexte, il est beaucoup plus lisible (pour la plupart des gens au moins) que, disons arrayIndexOfMyVerySpecialDataSet.
Beaucoup de stylistiques conventions (pas de règles!) Sensez au fil des ans en raison des limitations des environnements de programmation. Retour dans les journées de la carte de frappe, vous avez eu une limite dur limite le nombre de caractères pouvant apparaître sur une ligne source physique (qui était la raison pour laquelle Fortran réservé la colonne 6 pour les caractères de continuation de la ligne). Ce n'était pas que peu de décennies il y a plusieurs décennies que je travaillais sur un terminal 80x24 Amber-On-noir VT220; Pendant que les éditeurs que j'ai utilisés ne limitaient pas les lignes à 80 caractères, la vie n'était que beaucoup plus facile si vous faites de votre mieux pour éviter le défilement horizontal.
Sous les anciennes versions de Fortran (jusqu'à '77, IINM), vous ne pouviez même pas avoir identificateurs de plus de 6 à 8 caractères. Même aussi tard que les années 80, c garanties que les 8 premiers caractères des noms externes étaient significatifs (c'est pourquoi certaines fonctions de bibliothèque ont des noms merveilleusement descriptifs comme strpbrk).
Bien sûr, deux décennies au XXIe siècle, nous n'avons plus ces limites. Il n'y a aucune raison non d'utiliser plus d'identifiants descriptifs.
La chose est, dans les contextes droits, i et j et k sont parfaitement raisonnables, noms significatifs. Si je suis itération à travers un tableau ou un vecteur dans une boucle et que j'ai juste besoin de quelque chose pour identifier l'élément actuel, i fonctionne parfaitement bien. Je n'utiliserais pas de nom comme currentElement - ce n'est pas plus significatif dans ce contexte, et il ajoute simplement un encombrement visuel.
Cela dit, votre professeur n'a pas tort de vous obliger à penser en termes de noms plus longs et plus descriptifs pour tout - La vie sera plus facile pour vous si vous entrez dans cette habitude d'abord, puis apprenez où économiser si nécessaire. En tant que quelqu'un qui était à une fois, obligé de tout correspondre en 8 caractères ou moins, il est certainement préférable de se tromper sur le côté de plus d'informations que moins. Lorsque vous acquérirez plus d'expérience, vous apprendrez où vous pouvez économiser sur la longueur de l'identifiant et où vous devez être un peu plus descriptif.
Disclaimer: J'exagère un peu ici pour rendre mon point plus clair. Alors prenez tout superlatif avec un grain de sel.
Votre professeur est à 100% à droite: il n'y a plus de "règle d'or" d'environ 80 caractères (sauf si vous écrivez le code Linux, c'est-à-dire). Cette règle a été établie en raison de la taille des terminaux à l'époque, mais de nos jours, vous êtes facilement en train de créer plus de 150 caractères dans votre fenêtre Enditor. Et même si vous dépassez cette limite, votre éditeur espérons-le-chose que vous soyez logiciellement sur la ligne afin que vous n'ayez pas à faire défiler. et la seule raison de ne pas aller au-delà de 80 caractères était la nécessité de faire défiler.
Cela dit, il y a en effet un besoin de ne pas laisser vos lignes grandir indéfiniment. Plus la ligne est longue, plus il devient difficile pour un humain d'analyser. Mais les noms de variables courts ne sont pas le remède pour la question de Long Lines.
Le remède est de diviser vos expressions logiquement en introduisant des variables encore plus correctement nommées. N'essayez pas d'être intelligent avec des espaces. Il suffit d'identifier toute subexpression pouvant être nommée et créer une variable pour cela. qui simplifie à la fois le code calculant la variable et le code à l'aide de cette variable.
Pas une partie de votre question, mais j'aimerais commenter quand même: c'est une très mauvaise idée d'aligner verticalement votre = les opérateurs.
Il y a trois raisons pour cela:
Modification d'un bloc contenant des opérateurs verticalement alignés est un pita. Chaque fois que la longueur de la plus grande variable change (renommée, addition, suppression), vous devez retoucher toutes les lignes du bloc pour récupérer votre "belle" mise en page.
Bien entendu, ce problème peut être réduit un peu en utilisant un éditeur compétent, donc c'est la raison mineure. La vraie raison est la deuxième:
Ces changements de blanchissage parasites introduits en réalignant ne jouent pas bien avec des systèmes de contrôle de version modernes tels que
git. Ils ont tendance à créer des quantités importantes de conflits de fusion où aucun conflit réel n'est arrivé et où aucun conflit ne serait signalé si l'alignement n'était pas utilisé. chacun de ces conflits parasites vous coûtera un temps précieux pour rien.L'alignement porte zéro signification sémantique. C'est inutile. Il n'y a rien que vous puissiez mieux comprendre avec l'alignement. Chaque ligne de votre bloc doit lire seul pour comprendre ce qu'elle fait, la connexion aux lignes ci-dessus et ci-dessous est de nature purement syntaxique.
Étant donné que l'alignement ne porte aucune signification sémantique, mais produit des coûts importants, vous devez désapprendre l'habitude avant de vous coûter plus de temps.
Si vous aimez tellement la limite de 80 caractères, essayez de la programmation de Fortran. TRUE, les nouvelles normes ont soulevé la limite de ligne de la Fortrane à 132 caractères, mais il reste en vigueur comme toujours la compilation de tout programme qui dépasse la limite. Si vous êtes bon à la programmation, vous arriverez bientôt à haïr Fortran, y compris sa limite de longueur de ligne. Après cela, vous serez guéri pour le reste de votre vie.
Je devais faire de la programmation de Fortrane professionnellement et je vous le dis, cela m'a appris à détester cette longueur de ligne limite le plus cher. Il n'y a absolument rien de plus frustrant que de devoir diviser une ligne autrement simple et lisible en parties simplement parce que le compilateur ne le compilait plus correctement. Et il existe définitivement des lignes de code les plus simples quand elles sont exprimées en une seule ligne.