Saut de ligne avant / après opérateur [fermé]

Bien que la convention de code Java de Sun suggère de mettre le saut de ligne avant que l'opérateur ne soit en désaccord avec de nombreuses autres directives. Je ne vois pas d'avantages et d'inconvénients évidents, alors y a-t-il des avantages à utiliser l'un de ces styles par rapport à un autre?

String longVarName = a + b + c + d +
          e + f;

contre

String longVarName = a + b + c + d
          + e + f;

Je la laisserais sur une seule ligne et penserais plutôt à la lisibilité en termes de noms de variables révélant l'intention (et de fonctions).

Une fois qu'il devient désordonné, il est temps de refactoriser :

• renommer vars
• introduire de nouveaux vars / fonctions

Exemple

subtotal = price * (100 + tax_ratio) / 100`

contre.

tax = price * tax_ratio / 100
subtotal = price + tax

Je peux imaginer que la lisibilité soit un argument

result = longidentifier +
   short -
   alittlelonger -
   c;

contre

result = longidentifier
   + short
   - alittlelonger
   - c;

Dans le deuxième exemple, les opérateurs sont bien alignés et vous pouvez facilement voir avec quel signe la variable entre dans l'équation. Je pense que cela a également du sens pour les opérateurs binaires, mais avec le contreventement, etc., vous devez simplement faire ce qui est plus clair.

Je respecte normalement les directives de style les plus couramment utilisées ou certains outils standard de codage. L'avantage d'utiliser un style couramment utilisé apporte des avantages lorsque vous lisez le code d'autrui ou que vous êtes impliqué dans un projet open source où des directives de style sont définies.

Les styles les plus courants que j'ai vus sont le deuxième style de la question. Voir ci-dessous pour la liste d'entre eux:

Guide de style Google :

Lorsqu'une ligne est interrompue chez un opérateur sans affectation, la coupure précède le symbole.

Convention de codage solaire :

Pause devant un opérateur

Checkstyle opérateur Wrap contrôle de » la valeur par défaut est nl:

L'opérateur doit être sur une nouvelle ligne

Dans le code, j'ai tendance à mettre la pause après l'opérateur:

foo = some_long_expression() +
      some_other_long_expression();

Ici, cet opérateur pendant à la fin d'une ligne est un gros indice pour le lecteur que le code continue. Dans les langues qui n'ont pas de terminateurs d'instructions, cet opérateur pendant peut servir d'indice suffisant au compilateur / interprète pour que le code continue (sinon je devrais utiliser une construction de ligne de continuation laide).

Lors de la documentation de cette expression (si elle a besoin de documentation), j'ai tendance à mettre la pause avant l'opérateur.

Tant que vous restez cohérent, sachez qu'il n'y a aucun avantage réel dans les deux cas. Ceci est particulièrement important lorsque l'on considère les fusions de code et les espaces blancs.

Je pense que la ligne doit commencer par le symbole le plus élevé de l'arbre d'analyse de la déclaration que vous souhaitez rompre. Il met en évidence l'opérateur qui est le plus important dans l'expression. C'est la même raison pour laquelle vous mettez un autre au début d'une ligne et non à la fin de la ligne précédente.

Dans l'exemple suivant, en balayant la marge de gauche, vous voyez la structure de l'instruction comme un OU de 3 expressions.

if (ch>='A' && ch<='Z'
    || ch>='a' && ch<='z'
    || ch>='0' && ch<='9')
{...}

Ci-dessous, le || les opérateurs sont moins mis en évidence. Il est moins évident que c'est un || des expressions. Surtout si les lignes étaient de longueurs différentes.

if (ch>='A' && ch<='Z' ||
    ch>='a' && ch<='z' ||
    ch>='0' && ch<='9')
{...}

Et juste pour référence, c'est très faux. Le || les opérateurs ne sont pas du tout mis en évidence.

if ( ch>='A' && ch<='Z' || ch>='a'
     && ch<='z' || ch>='0' && ch<='9')
{...}

J'aime même mettre des virgules au début de la ligne, même si je le vois rarement. Je m'abstiens de le faire sur du code partagé.

var note:Object =
    { key: key
    , type: 'P'
    , text: someLongProcedureCallGettingTheUserInitials()
       + ": " + getTheTextThatWasTyped()
    };

Pour les longues équations arithmétiques, je fais généralement l'une des deux choses.

tout laisser sur une seule ligne:

foo = bar + baz - fizz + buzz + alpha - beta;

Je fais généralement cela pour les équations contenant uniquement l' addition et la soustraction, je trouve très facile de faire une faute de frappe avec multiplication et division qui peut sérieusement gâcher la portée de l'opérateur.

le deuxième format que j'utilise est celui des opérateurs progressifs:

foo = bar;
foo += baz;
foo -= fizz;
foo += buzz;
foo /= alpha - beta;
foo *= spiff;

Je ne vois aucune raison de le raccourcir en une seule ligne, à moins qu'il puisse être prouvé qu'il améliore les performances de manière notable. De plus, il n'y a aucune ambiguïté sur ce qui se passe où et il y a moins de chance de perdre une parenthèse pour les opérateurs /et *.

Le fait de placer le caractère de concaténation (ou n'importe quel opérateur) au début de la ligne améliore la lisibilité. Nous scannons le code en nous concentrant sur le début de chaque ligne. Lorsqu'une ligne commence par un opérateur, le lecteur peut dire que la ligne est une continuation de l'instruction précédente en scannant ce caractère.

Les expressions mathématiques longues sont toujours composées de sorte que chaque nouvelle ligne commence par un opérateur. Il n'y a aucune raison pour que le code ne suive pas cette convention.

Laissez l'expression sur une ligne et si elle devient trop longue, divisez-la en expressions plus petites:

days = ((year * months_per_year) + month) * days_per_month + day

devient:

months = year * months_per_year + month
days = months * days_per_month + day

Si ce n'est pas possible, je trouve qu'il est plus lisible de casser avant l'opérateur, et que l'opérateur commence directement en dessous de l'affectation précédente (le placer en dessous de la variable me fait penser et recentrer, ce qui est ennuyeux étant donné que l'objectif est de rendre les choses plus faciles à lire):

random = years * months_per_year 
         + month * days_per_month 
         + day * hours_per_day 
         + hour * minutes_per_hour 
         + minute * seconds_per_minute 
         + second