Zeilenumbruch vor / nach Operator [geschlossen]

Während die Java-Codekonvention von Sun vorschlägt, Zeilenumbrüche vor den Operator zu stellen, stimmen viele andere Richtlinien nicht mit der Java-Codekonvention überein. Ich sehe keine offensichtlichen Vor- und Nachteile. Gibt es also Vorteile, wenn Sie einen dieser Stile gegenüber einem anderen verwenden?

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

vs

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

Ich lasse es in einer Zeile und denke eher über die Lesbarkeit nach, wenn es darum geht, Variablennamen (und Funktionen) zu enthüllen.

Sobald es chaotisch wird, ist es Zeit zu überarbeiten :

• Benennen Sie vars um
• neue vars / funktionen einführen

Beispiel

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

gegen

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

Ich kann mir vorstellen, dass Lesbarkeit ein Argument ist

result = longidentifier +
   short -
   alittlelonger -
   c;

gegen

result = longidentifier
   + short
   - alittlelonger
   - c;

Im zweiten Beispiel sind die Operatoren aneinander gereiht und Sie können leicht erkennen, mit welchem ​​Vorzeichen die Variable in die Gleichung eingeht. Ich denke, dass dies auch für binäre Operatoren Sinn macht, aber bei Klammern etc. sollte man einfach das tun, was klarer ist.

Normalerweise befolge ich die am häufigsten verwendeten Stilrichtlinien oder bestimmte Standard-Codierungswerkzeuge. Der Vorteil der Verwendung eines häufig verwendeten Stils bietet Vorteile, wenn Sie den Code anderer lesen oder an einem Open Source-Projekt teilnehmen, in dem Stilrichtlinien festgelegt sind.

Der häufigste Stil, den ich gesehen habe, ist der zweite in der Frage. Unten finden Sie eine Liste von ihnen:

Google Style Guide :

Wenn eine Zeile bei einem Operator ohne Zuweisung unterbrochen wird, steht der Umbruch vor dem Symbol.

Sun Coding Convention :

Pause vor einem Bediener

Check Operator Wrap Check ‚s Standardwert ist nl:

Der Bediener muss sich in einer neuen Leitung befinden

In Code neige ich dazu, die Pause nach dem Operator zu setzen:

foo = some_long_expression() +
      some_other_long_expression();

Hier ist der baumelnde Operator am Ende einer Zeile ein großer Hinweis für den Leser, dass der Code fortgesetzt wird. In Sprachen, die keine Anweisungsabschlusszeichen haben, kann dieser baumelnde Operator als ausreichender Hinweis für den Compiler / Interpreter dienen, dass der Code fortgesetzt wird (andernfalls müsste ich ein hässliches Fortsetzungszeilenkonstrukt verwenden).

Wenn ich diesen Ausdruck dokumentiere (wenn er dokumentiert werden muss), neige ich dazu, die Pause vor den Operator zu stellen.

Solange Sie konsequent bleiben, wissen Sie, dass es keinen wirklichen Vorteil gibt. Dies ist besonders wichtig, wenn Sie Code-Zusammenführungen und Leerzeichen berücksichtigen.

Ich glaube, die Zeile sollte mit dem höchsten Symbol im Analysebaum der Anweisung beginnen, die Sie unterbrechen möchten. Es hebt den Operator hervor, der im Ausdruck am wichtigsten ist. Aus dem gleichen Grund setzen Sie ein else am Anfang einer Zeile und nicht am Ende der vorherigen Zeile.

Im folgenden Beispiel wird beim Scannen des linken Rands die Struktur der Anweisung als ODER von 3 Ausdrücken angezeigt.

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

Unten die || Bediener sind weniger hervorgehoben. Es ist weniger offensichtlich, dass es sich um ein || handelt von Ausdrücken. Vor allem, wenn die Linien unterschiedlich lang waren.

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

Und nur als Referenz, das ist sehr falsch. Die || Operatoren werden überhaupt nicht hervorgehoben.

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

Ich setze sogar gerne Kommas an den Anfang der Zeile, obwohl ich das selten sehe. Ich verzichte auf Shared Code.

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

Für lange arithmetische Gleichungen mache ich normalerweise eines von zwei Dingen.

alles in einer einzigen Zeile belassen:

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

Ich mache dies normalerweise für Gleichungen, die nur Addition und Subtraktion enthalten. Ich finde es sehr einfach, einen Tippfehler mit Multiplikation und Division zu machen, der den Umfang des Operators ernsthaft verfälschen kann.

Das zweite Format, das ich benutze, sind progressive Operatoren:

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

Ich sehe keinen Grund, es auf eine einzelne Zeile zu kürzen, es sei denn, es kann nachgewiesen werden, dass es die Leistung spürbar verbessert. Außerdem gibt es keine Unklarheit darüber, was wo vor sich geht, und es besteht weniger die Möglichkeit, eine Klammer für die Operatoren /und falsch zu platzieren *.

Das Platzieren des Verkettungszeichens (oder eines beliebigen Operators) am Anfang der Zeile verbessert die Lesbarkeit. Wir scannen den Code, indem wir uns auf den Anfang jeder Zeile konzentrieren. Wenn eine Zeile mit einem Operator beginnt, kann der Leser erkennen, dass die Zeile eine Fortsetzung der vorherigen Anweisung ist, indem er dieses eine Zeichen scannt.

Lange mathematische Ausdrücke werden immer so gesetzt, dass jede neue Zeile mit einem Operator beginnt. Es gibt keinen Grund, warum Code dieser Konvention nicht folgen sollte.

Lassen Sie den Ausdruck in einer Zeile, und wenn er zu lang wird, teilen Sie ihn in kleinere Ausdrücke auf:

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

wird:

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

Wenn dies nicht möglich ist, ist es für mich lesbarer, vor dem Operator zu brechen und den Operator direkt unter der vorherigen Zuweisung beginnen zu lassen (wenn ich ihn unter die Variable setze, muss ich nachdenken und neu zentrieren, was angesichts des Ziels ärgerlich ist ist es, die Dinge leichter lesbar zu machen):

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