Perché non dovremmo mettere le parentesi sulla stessa riga? [chiuso]

Riguarda i rientri

Non riguarda le parentesi, riguarda il rientro e l'allineamento verticale.

Non rientrato

puoi mettere parentesi sulla stessa riga quando il rientro non è in gioco.

Esempio nell'espressione lambda:

list.ForEach(  a => { a.Init(); a.DoSomething(); a.Complete(); });

Esempio di dichiarazione di un'interfaccia vuota, come questa trovata nel CLR .NET:

interface IRequiresSessionState {}

Rientri semplici

Ma se prevedi di indentare qualcosa, la regola di identificazione dice che le cose che iniziano e terminano un blocco di codice dovrebbero essere rientrate in modo simile, e le cose all'interno del blocco dovrebbero essere un livello più profondo, come questo:

void DoSomething() {
    Code();
}

L'idea è che puoi tracciare l'inizio e la fine del blocco ingrandendolo verticalmente.

Non lo faresti:

    void DoSomething() {
        Code();
}

o questo:

void DoSomething() {
    Code();
    }

perché non puoi usare l'occhio per trovare l'inizio che va alla fine.

Doppie indentazioni

Detto questo, puoi chiudere due blocchi sulla stessa riga, se hai aperto due blocchi sulla stessa linea, come in questo esempio di Javascript molto comune:

document.ready(function() {
                 DoSomething();
              });

o

while(flag) { for (i=1; i<10; i++) {
                 DoSomething();
            }};

... anche se francamente non penso che utilizzerei mai un costrutto come quello.

Un motivo per cui posso pensare è che mettere le parentesi di chiusura su singole linee rende più facile (non) commentare l'intero blocco usando // senza rompere la sintassi.

Vuoi essere in grado di distinguere le affermazioni e vedere dove inizia un blocco / composto e dove finisce. Questo è il motivo per cui lo stile Allman è superiore:

if (condition)
{
  // compound content
}

Tuttavia, alcune persone si sono abituate al vecchio stile K & R di salvataggio della carta:

if (condition) {
    // compound content
}

che rende più difficile vedere i blocchi perché i caratteri di apertura e chiusura non si trovano nella stessa colonna ed è più difficile distinguere la condizione dal blocco. Ma puoi ancora vedere una dichiarazione. La parentesi di apertura è un po 'disfunzionale, proprio lì dopo la condizione perché ha bisogno di essere presente da qualche parte. Ma quello conclusivo è perfettamente in linea con l'inizio della dichiarazione.

Ora questo ...

if (condition) {
    if (condition) {
        // compound content
}   }

Sia i discepoli Allman che K & R saranno d'accordo che questo è semplicemente orribile. perché non hai alcun riferimento che ti aiuti a vedere i blocchi di istruzioni. Sembra anche che l'ultimo {appartenga all'istruzione if interna, che non è così.

In questo caso molto specifico porta a un codice molto fuorviante e il codice fuorviante è un codice errato. A prima vista sembra che la prima parentesi di chiusura sia per il% esterno% co_de ma in realtà appartiene al% interno% co_de

L'articolo di Wikipedia su questo ( collegamento ) mostra due stili di indentazione (tra i nove elencati) che posizionano la chiusura rinforzi dopo l'ultima riga di codice (a differenza di una riga di per sé):

Pico:

while (x == y)
{   something();
    somethingelse(); }

Lisp:

while (x == y) {
    something();
    somethingelse(); }

Quello che suggerisci sembra essere lo stile Lisp. Tuttavia, riconosco che il tuo è un po 'ibrido - il primo rinforzo è su una nuova riga, ma le parentesi duplicate sono compresse.

La questione del perché non hai visto molte discussioni a riguardo è probabilmente perché le persone sono generalmente d'accordo sul fatto che questa è una brutta cosa! Ci sono alcune ovvie ragioni per cui ciò causerebbe problemi (difficile commentare, più difficile da leggere, ecc.) E la questione ideologica se l'inizio del blocco è il tutore o l'affermazione che lo precede non si applica in realtà la parentesi di chiusura (eccetto, forse, in un ciclo do...while ), quindi c'è molto meno da riscaldare.

Ci sono tre posizioni in qualsiasi blocco di codice in cui si desidera inserire o eliminare una riga: prima della prima riga esistente, tra due linee esistenti, dopo l'ultima linea esistente.

Il secondo è facile. Il primo e il terzo sono ciò che detta la posizione delle parentesi di apertura e chiusura. Se la parentesi si trova sulla stessa linea della linea di codice esistente, soffrirai e, prima o poi, qualcuno lo rovinerà.

Ovviamente, è tutta una questione di leggibilità umana, dal momento che la macchina non dà il gomito di un topo in un modo o nell'altro. E per quanto riguarda gli umani, "è tutto negli occhi di chi guarda", quindi non può esserci una risposta matematicamente corretta inequivocabile. Ma una risposta è "standard", allo stesso modo in cui il layout della tastiera QWERTY è diventato standard: dopo un po ', tutti si sentono abbastanza a proprio agio con esso.

Ma il mio stile particolare, prendilo o lascia, è in qualche modo dipendente dal contesto. Per brevi blocchi di codice, di solito non inserisco la chiusura "} " su una riga separata, ad es.

if ( this ) {
  that1;
  that2; }

Ma per blocchi più lunghi

while ( this ) {
  that1;
  that2;
  etc;
  } /* --- end-of-while(this) --- */

non solo metto il closing "} " su una riga separata, lo etichetto con un commento che ne definisce l'ambito. (Personalmente, odio l'evidenziazione della sintassi emacs-e-simile che lampeggia per il delimitatore di accoppiamento, ma sono solo io:).

Quindi la mia opinione personale è che uno standard scolpito nella pietra per questo aspetto dello stile sia eccessivo. Osservi il codice che stai scrivendo e prova a scriverlo in uno stile che sarà più leggibile per il prossimo povero slob che arriva e deve leggerlo e mantenerlo.