Comment suivre la meilleure pratique de limite de 80 caractères lors de l'écriture de code source?

Donc, comme vous le savez, il existe une meilleure pratique en disant

Limitez une ligne de code source à 80 caractères.

Voici 2 liens:

Pourquoi 80 caractères sont-ils la limite «standard» pour la largeur du code?

La limite de 80 caractères est-elle toujours pertinente à l'époque des moniteurs à écran large?

Et je suis sûr que vous pouvez affiner davantage si vous recherchez cette meilleure pratique.

Mais je trouve cela extrêmement difficile, voici un exemple:

public class MyClass {

    public void myMethod() {

        final Map<String, List<MyInterfaceHere>> myReference

Donc, vous indentez chaque classe et chaque méthode et chaque instruction.

Et je suis déjà à la colonne 60 à la fin du dernier «e» que j'ai dans «maRéférence».

Il me reste 20 espaces pour appeler le constructeur et assigner l'objet à la référence que j'ai.

Je veux dire, cela semble-t-il vraiment mieux:

public class MyClass {

    public void myMethod() {

        final Map<String, List<MyInterfaceHere>> myReference 
                = new HashMap<String, List<MyInterfaceHere>>(); 

Quelle est la meilleure pratique ici?

La meilleure pratique devrait être de "limiter la longueur d'une ligne pour que vous, tous vos collègues et tous les outils que vous utilisez en soient satisfaits", plus du bon sens. 80 caractères semblent très faibles et tendent à réduire la lisibilité. J'ai déjà été totalement trompé par une ligne comme celle-ci:

/* Very long comment to the end of the line */ realCode ();

où l'appel de fonction n'était pas visible à l'écran (il n'était pas non plus visible à l'écran d'un collègue) sans indication.

J'ai configuré mon éditeur pour afficher une marge de 100 colonnes, ainsi que le reconditionnement du code à l'écran, de sorte que tout est toujours visible lors de l'édition, et les lignes trop longues ont tendance à être divisées manuellement en deux ou parfois plus de lignes. Priez pour que votre éditeur formate correctement les instructions fractionnées s'il effectue un formatage automatique. Utilisez un style de codage qui ne conduit pas à des instructions profondément imbriquées. (Certaines personnes créent un nid de vingt instructions if suivies d'une queue de vingt autres, ce qui conduit à une indentation profonde de 200 caractères, et personne ne peut déterminer à qui appartient d'autre qui si).

Dans votre cas particulier, Swift a inventé un moyen d'éviter cela: une variable "let" (qui est à peu près la même que "final" dans d'autres langues) doit recevoir une valeur exactement une fois avant d'être utilisée, mais pas nécessairement dans la déclaration , afin que vous puissiez diviser votre ligne problématique en deux déclarations indépendantes.

PS. J'ai rencontré des lignes, en vrai code humain, qui dépassaient 400 caractères. En d'autres termes, vous devrez faire défiler les âges pour lire le reste de la ligne, même sur un moniteur 24 pouces. Je n'étais pas amusé :-(

Oui, ça a l'air mieux. C'est pourquoi le "N'utilisez pas de lignes trop longues!" maxime est donc très forte.

Quant aux meilleures pratiques, je n'utilise jamais ces expressions horriblement longues de constructeur. J'utiliserais toujours

public class MyClass {

    public void myMethod() {

        final Map<String, List<MyInterfaceHere>> yReference = newMap();

pour une valeur importée statiquement définie de newMap(). Je considère que c'est un grave défaut dans Java car il n'a pas de version intégrée.

L'objectif n'est pas de "garder des lignes à 80 caractères". L'objectif est de "rendre votre code facile à lire et à comprendre". La limite artificielle de 80 caractères aide à la lisibilité, mais ce n'est pas une règle stricte et rapide à moins que votre équipe ne le décide.

Vous avez demandé la meilleure pratique, et la meilleure pratique est de "se concentrer sur la façon de rendre le code aussi lisible que possible". Si cela nécessite plus de 80 caractères, tant pis.

N'ayez pas peur d'appuyer sur la touche Retour. La plupart des langages modernes (y compris Java comme dans votre exemple) sont très satisfaits des instructions qui s'étendent sur plusieurs lignes.

Réfléchissez simplement à l'endroit où vous rompez les lignes et vous pouvez obtenir quelque chose qui correspond à une limite de 80 colonnes et qui reste parfaitement lisible. Les conventions de codage Java officielles spécifient même les emplacements préférés pour couper les lignes.

Fait à droite, une ligne soigneusement découpée est beaucoup plus lisible que celle qui disparaît du côté de l'écran.

Si vous appliquez la longueur / largeur de ligne du code, utilisez un outil.

• Resharper
• Visual Assist
• etc.

Les développeurs décident quelle longueur raisonnable est (80, 120, 200, etc.), définissez cette option dans l'outil.

Après cela, écrivez simplement le code comme vous le feriez normalement sans tenir compte de la largeur ou de la longueur de la ligne. Une fois qu'il est fonctionnel et terminé, faites un clic droit et choisissez Nettoyer le code ou une option similaire. L'outil formatera le code comme vous l'avez dit et coupera les longues lignes comme indiqué.

Insensé et facile et chaque fichier source sera formaté de la même manière.

La limite de 80 caractères peut être un peu trop courte de nos jours, mais cela aide. Je suis d'accord avec toutes ces opinions que le code devrait également être bien formaté. par exemple le code

/ * Très long commentaire à la fin de la ligne * / realCode ();

peut être dans les 80 chr mais crée de la confusion car les remarques et les options de code sont sur la même ligne.

Adhérer ou non à la limite de 80 chr est le choix des individus, mais si les choses sont visibles en une seule prise, cela donnera toujours une vision et une sensation confortables aux programmeurs et aux autres examinateurs.