web-dev-qa-db-fra.com

Saut de ligne avant / après opérateur

Bien que la convention de code Java Java 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, il y a donc des avantages à utiliser un autre?

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

contre

String longVarName = a + b + c + d
          + e + f;
javacoding-standardscoding-style
31
Nutel

Je le 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 est en désordre, il est temps de refactoriser:

  • renommer les variables
  • introduire de nouvelles variables/fonctions

Exemple

subtotal = price * (100 + tax_ratio) / 100

vs.

tax = price * tax_ratio / 100
subtotal = price + tax
16
Kamil Tomšík

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:

Google Style Guide :

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

Convention de codage solaire :

Pause devant un opérateur

Checkstyle Operator Wrap check 's valeur par défaut is nl:

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

37
ceilfors

Je peux imaginer que la lisibilité soit un argument

result = longidentifier +
   short -
   alittlelonger -
   c;

versus

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.

37
Otto Allmendinger

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.

10
David Hammen

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 OR 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()
    };
3
Florian F

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.

3
Martijn Verburg

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 le fais généralement pour les équations contenant niquement addition et 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 le / et * les opérateurs.

2
zzzzBov

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.

2
kevin cline

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
0
Joel