Interruzione di linea prima / dopo l'operatore [chiuso]

Mentre la convenzione sul codice Java di Sun suggerisce di mettere l'interruzione di linea davanti all'operatore molte altre linee guida non sono d'accordo. Non vedo alcun pro e contro ovvio, quindi ci sono vantaggi nell'usare uno di questi stili rispetto a un altro?

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

vs

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

Lo lascerei su una riga e preferirei piuttosto la leggibilità in termini di nomi (e funzioni) che rivelano l'intenzione.

Una volta che diventa disordinato è il momento di refactoring :

• rinominare var
• introdurre nuove funzioni / var

Esempio

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

vs.

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

Posso immaginare che la leggibilità sia un argomento

result = longidentifier +
   short -
   alittlelonger -
   c;

contro

result = longidentifier
   + short
   - alittlelonger
   - c;

Nel secondo esempio gli operatori sono ben allineati e puoi facilmente vedere con quale segno la variabile entra nell'equazione. Penso che ciò abbia senso anche per gli operatori binari, ma con il controvento ecc., Dovresti semplicemente fare tutto ciò che è più chiaro.

Di solito seguo le linee guida di stile più comunemente usate o alcuni strumenti standard di codifica. Il vantaggio di utilizzare uno stile di uso comune porta vantaggi quando si legge il codice di altre persone o si è coinvolti in un progetto open source in cui sono stabilite le linee guida di stile.

Gli stili più comuni che ho visto è il secondo stile nella domanda. Vedi sotto per l'elenco di loro:

Guida allo stile di Google :

Quando una linea viene interrotta da un operatore non assegnato, l'interruzione precede il simbolo.

Convenzione sul codice solare :

Pausa prima di un operatore

Wrap Operatore Checkstyle controllo 's valore predefinito è nl:

L'operatore deve essere su una nuova linea

Nel codice tendo a mettere la pausa dopo l'operatore:

foo = some_long_expression() +
      some_other_long_expression();

Qui quell'operatore penzolante alla fine di una riga è un grande indizio per il lettore che il codice continua. Nei linguaggi che non hanno terminatori di istruzioni, quell'operatore penzolante può servire come indizio sufficiente al compilatore / interprete che il codice continua (altrimenti dovrei usare un brutto costrutto di linea di continuazione).

Nel documentare quell'espressione (se necessita di documentazione), tendo a mettere la pausa davanti all'operatore.

Finché rimani coerente, allora sappi che non c'è alcun vantaggio reale in entrambi i modi. Ciò è particolarmente importante quando si considerano le fusioni di codice e lo spazio bianco.

Credo che la linea dovrebbe iniziare con il simbolo più alto nella struttura di analisi dell'istruzione che si desidera interrompere. Evidenzia l'operatore che è più importante nell'espressione. È lo stesso motivo per cui hai inserito un altro all'inizio di una riga e non alla fine della riga precedente.

Nell'esempio seguente, analizzando il margine sinistro, viene visualizzata la struttura dell'istruzione come OR di 3 espressioni.

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

Sotto, il || gli operatori sono meno evidenziati. È meno ovvio che si tratta di un || di espressioni. Soprattutto se le linee avevano lunghezze diverse.

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

E solo per riferimento, questo è molto sbagliato. Il || gli operatori non sono affatto evidenziati.

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

Mi piace persino mettere le virgole all'inizio della riga, anche se raramente lo vedo. Mi astengo dal farlo sul codice condiviso.

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

Per lunghe equazioni aritmetiche, in genere faccio una delle due cose.

lascia tutto su una sola riga:

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

In genere lo faccio per equazioni contenenti solo addizioni e sottrazioni, trovo molto facile fare un refuso con moltiplicazione e divisione che può seriamente rovinare l'ambito dell'operatore.

il secondo formato che utilizzo sono operatori progressivi:

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

Non vedo alcun motivo per accorciarlo su una sola riga, a meno che non si possa dimostrare che migliora le prestazioni in modo evidente. Inoltre, non vi è alcuna ambiguità su ciò che sta succedendo, e c'è meno possibilità di collocare erroneamente una parentesi per gli operatori /e *.

Posizionare il carattere di concatenazione (o qualsiasi operatore) all'inizio della riga migliora la leggibilità. Effettuiamo la scansione del codice concentrandoci sull'inizio di ogni riga. Quando una linea inizia con un operatore, il lettore può dire che la linea è una continuazione dell'istruzione precedente scansionando quel carattere.

Le espressioni matematiche lunghe sono sempre composte in modo che ogni nuova riga inizi con un operatore. Non vi è alcun motivo per cui il codice non dovrebbe seguire questa convenzione.

Lascia l'espressione su una riga e, se diventa troppo lunga, suddividila in espressioni più piccole:

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

diventa:

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

Se ciò non è possibile, allora trovo più leggibile interrompere prima dell'operatore e farlo iniziare direttamente sotto il compito precedente (metterlo sotto la variabile mi fa pensare e più recente, il che è fastidioso dato che l'obiettivo è rendere le cose più facili da leggere):

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