Le parentesi graffe dovrebbero apparire sulla propria riga? [chiuso]
Su Febbraio 14, 2021 da adminCommenti
- Ho trovato " == true " più fastidioso della scelta del posizionamento del tutore.
- @Dan: Penso che spiegare sempre lespressione condizionale sia di grande aiuto per la chiarezza.
- Lunico motivo per questo sarebbe sarebbe importante se il tuo IDE / editor non ' t supporta il riconoscimento delle parentesi graffe corrispondenti.
- @ leeand00: alcuni di noi stampano ancora codice complesso / sconosciuto per studiarlo / annotarlo. Tuttavia, una buona stampante carina mitiga la maggior parte dei problemi.
- triste la domanda è chiusa. Dopo un po di tempo di utilizzo della sintassi basata sul rientro sono passato a (forse strana) unaltra struttura di parentesi graffe. Come la tua prima parentesi graffa ma di chiusura nellultima riga del blocco. (dopo la riga di codice)
Risposta
Quando ero uno studente usavo mettere le parentesi graffe sullo stesso riga, in modo che ci siano meno righe e il codice venga stampato su meno pagine. Guardare un singolo carattere di parentesi stampato come lunica cosa in una riga è fastidioso. (ambiente, spreco di carta)
Ma quando si codificano applicazioni di grandi dimensioni, consentire alcune linee con solo parentesi graffe è conveniente, considerando la sensazione di “raggruppamento” che dà.
Qualunque stile tu scelga , sii coerente in modo che non diventi un sovraccarico per il tuo cervello elaborare più stili in parti di codice correlate . In diversi scenari (come sopra) direi che va bene usare stili diversi, è più facile “cambiare contesto” ad alto livello.
Commenti
- Daltra parte, la parentesi graffa sulla nuova riga è uno STANDARD ANSI, K & R non lo è. Ma il bello degli standard è che ce ne sono così tanti diversi (vedi anche unciclopedia.wikia.com/wiki/AAAAAAAAA ! sullenciclopedia).
- " ci sono meno righe " Ho terabyte di spazio e molti pixel. Perché dovrei utilizzare più righe?
- @ 12431234123412341234123: I penso che voglia dire perché alcune persone stampano il codice per la revisione del codice. E ogni nuova riga non assolutamente necessaria è carta sprecata, o un km ² di bosco sprecato su larga scala. Tuttavia, se tu don ' t stamparlo (certamente non ' t) allora ANSI è molto meglio di K & R. Inoltre, chiunque intenda stampare dovrebbe probabilmente utilizzare un formattatore di codice automatico, quindi questa dovrebbe essere una questione di strumenti, non di stile di codifica.
- Sono daccordo che dovresti rimanere coerente, I ' Sto usando le parentesi graffe su nuove righe da anni, ma devo mescolare in un altro modo nel mio codice, come quando chiamo funzioni, funzioni anonime, oggetti letterali ecc. Qualsiasi linguaggio basato su espressioni / codice anonimo rende le parentesi sulla stessa riga molto più facili
Answer
Non dovresti mai usare il terzo metodo.
Risparmiare sulle parentesi graffe potrebbe farti risparmiare qualche battitura la prima volta, ma il prossimo programmatore che arriva lungo, aggiunge qualcosa alla tua clausola else senza notare che il blocco manca parentesi graffe sta per essere molto doloroso.
Scrivi il tuo codice per altre persone.
Commenti
- Vorrei sapere da dove ha avuto origine quel po di saggezza. Perché scrivere il tuo codice per le persone che hanno vinto ' non si sono preoccupati di leggerlo è inutile quanto puoi …
- Il secondo programmatore può aggiungere il suo parentesi graffe quando aggiunge qualcosa. Non è ' stupido e in una convenzione di codifica che incoraggia lomissione di parentesi graffe per cose semplici come questa, ' saprà guardare.
- Le parentesi graffe opzionali non sono opzionali. Ci sono poche decisioni di progettazione peggiori che sono state prese in C e riportate ai suoi discendenti. Il fatto che sopravviva in una lingua recente come C # mi fa infuriare.
- Non ' importa quanto sei intelligente o quanto sia radicato lo standard di codifica attorno ai ricci omessi a riga singola: se ' stai cercando di risolvere un problema o un bug, probabilmente ti perderai che i ricci sono stati omessi. E per un totale di 2 secondi di lavoro, è davvero così brutto essere espliciti?
- Cè ' un vantaggio dello stile n. 3 che tu ' manca tutto: ottieni più codice sullo schermo contemporaneamente.
Risposta
Per molto tempo ho sostenuto che avevano lo stesso valore, o così molto vicino a che il possibile guadagno facendo la scelta giusta era di gran lunga inferiore al costo di discutere al riguardo.
Essere coerente è importante , però. Così ho detto lanciamo una moneta e cominciamo a scrivere codice.
Ho già visto programmatori resistere a cambiamenti come questo prima. Farsene una ragione! Ho cambiato molte volte nella mia carriera. Uso persino stili diversi nel mio C # rispetto al mio PowerShell.
Qualche anno fa stavo lavorando su un team (~ 20 sviluppatori) che ha deciso di chiedere input, quindi prendere una decisione, quindi applicarla a tutta la base di codice. Abbiamo una settimana per decidere.
Molti gemiti & occhio -rolling. Un sacco di “Mi piace il mio modo, perché” è migliore “ma non di sostanza.
Mentre stavamo studiando i punti più fini della domanda, qualcuno ha chiesto come affrontare questo problema in coppia. -stile della stessa riga:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
Nota che non è immediatamente ovvio dove finisce lelenco dei parametri e inizia il corpo. Confronta con:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
Abbiamo letto come le persone in tutto il mondo hanno affrontato questo problema e abbiamo trovato lo schema per aggiungere una riga vuota dopo lapertura parentesi graffa:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
Se stai per fare una pausa visiva, puoi anche farlo con una parentesi graffa. Quindi anche le tue interruzioni visive diventano coerenti .
Modifica : due alternative alla soluzione “riga vuota extra” quando si utilizza K & R:
1 / Rientra gli argomenti della funzione in modo diverso dal corpo della funzione
2 / Metti il primo argomento sulla stessa riga del nome della funzione e allinea ulteriori argomenti su nuove righe a quel primo argomento
Esempi:
1 /
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
2 /
void MyFunction(int parameterOne, int parameterTwo) { int localOne, int localTwo }
/ Modifica
Continuo a sostenere che la coerenza è più importante di altre considerazioni, ma se non abbiamo un ha stabilito un precedente , quindi la parentesi graffa sulla riga successiva è la strada da percorrere.
Commenti
- Cordiali saluti, potrei sembrare una persona ragionevole, ma ' in realtà sono un pazzo. Per semplici blocchi di una sola riga, non userò né parentesi graffe né newline, rendendo ' if (foo) bar () ' tutto uno linea. Mi sforzo di rendere il mio codice abbastanza semplice da ' non è un problema.
- Sono venuto qui per pubblicare esattamente questo. Tonnellate di persone che mantengono la parentesi graffa di apertura sulla stessa riga la seguono con una riga vuota (specialmente allinizio di classi e metodi) perché altrimenti ' s difficile separare lintestazione della classe / del metodo dal corpo. Bene, se ' utilizzerai comunque una riga in più, puoi anche inserire la parentesi graffa lì e ottenere il vantaggio aggiuntivo del rientro che è più facile da vedere.
- ' non ho visto la riga vuota – ' ho più familiarità con il doppio rientro dei parametri per MyFunction () quando si allontanano su unaltra riga.
- Suddividere i parametri su più righe in questo modo è esasperante.
- Il " parametro della funzione " largomento è una falsa pista. Ovviamente gli argomenti dovrebbero essere doppiamente intesi. Nessun problema per distinguerlo dal codice seguente.
Risposta
Le regole cardinali sono:
- Segui lo standard di codifica esistente del progetto.
- Se non esiste uno standard di codifica e stai modificando una base di codice esistente di proprietà di qualcun altro, sii coerente con lo stile del codice esistente, non importa quanto ti piaccia / non ti piaccia.
- Se stai lavorando a un progetto green field, discuti con altri membri del team e raggiungi un consenso su uno standard di codifica formale o informale.
- Se stai lavorando a un progetto green field come unico sviluppatore, prendi una decisione e sii spietatamente coerente .
Anche se non hai vincoli esterni su di te, è (IMO) meglio cercare uno standard di codifica esistente (ampiamente utilizzato) o una linea guida di stile e provare a seguirlo. Se scegli il tuo stile, ci sono buone probabilità che te ne pentirai tra qualche anno.
Infine, uno stile implementato / implementabile utilizzando i controllori di stile esistenti e i formattatori di codice è meglio di uno che deve essere “applicato” manualmente.
Commenti
- Questa risposta merita più voti.
- coerenza è la chiave
Risposta
Il vantaggio del primo metodo è che è più compatto verticalmente , in modo da poter inserire più codice sullo schermo, ed è per questo che lo preferisco. Lunico argomento che ho sentito a favore del secondo metodo è che rende più facile accoppiare le parentesi di apertura e chiusura, ma la maggior parte degli IDE ha un scorciatoia da tastiera per questo, ed è effettivamente una dichiarazione falsa – invece di accoppiare una parentesi di apertura a una parentesi di chiusura puoi accoppiare una parentesi di chiusura allespressione di “inizio blocco” (if, else, for, while) sullo stesso livello di rientro, quindi è altrettanto facile determinarlo dove si trova linizio del blocco.
Non vedo alcun motivo per sprecare unintera riga solo per una parentesi quando il precedente costrutto for / while / if indica già visivamente linizio di un blocco.
Detto questo, credo che la parentesi di chiusura dovrebbe essere nella propria riga perché abbiamo bisogno di qualcosa per indicare la fine di un blocco e la sua struttura di rientro in modo visibile.
Commenti
- No … ' sto dicendo perché ridurre la quantità di codice che può adattarsi allo schermo facendo qualcosa che ' non aggiunge al codice ' è chiarezza?
- Quando io stava iniziando a programmare mi piaceva ogni parentesi graffa sulla propria linea, ora preferisco il primo metodo
- Cè un enorme corpo di ricerca, che risale alla prima età di Steam (Weinberg, " Psicologia della programmazione informatica "), che mostra che la comprensione del programmatore diminuisce in modo DRAMMATICO quando la quantità di codice che deve essere visualizzato è superiore a quella che può essere vista in una volta (cioè una schermata, una pagina della stampante). Questo fenomeno sostiene FORTEMENTE per vedere lo spazio verticale come una risorsa preziosa, da non sprecare gratuitamente, e quindi il primo metodo è preferito.
- LOL @ " sprecare un INTERA riga ". OH MIO DIO! Non quello!! = P
- @Julio Al college ho preferito fortemente il metodo 1 e non potevo ' sopportare di leggere il metodo 2. Dopo essere andato a lavorare in unazienda che utilizza C # , dove lo standard è il metodo 2, ' sono arrivato allo stesso modo. Ora posso leggere o utilizzare entrambi; nessuno mi dà fastidio. Le persone che hanno una reazione fortemente contraria alluna o allaltra generalmente reagiscono in modo eccessivo a qualcosa con cui non hanno familiarità.
Risposta
Preferisco
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
rispetto a
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
perché la riga you.postAnswer();
è molto più facile da leggere e trovare a prima vista. Nel secondo modo, si fonde con la riga sopra di esso (you.hasAnswer()
) costringendo i miei occhi a concentrarsi maggiormente per leggerlo.
Commenti
- Questo è vero finché il tuo programma non supera laltezza dello schermo. 😉
- @ weberc2 Penso che quando il tuo programma supera laltezza dello schermo, due righe in meno non ' cambieranno molto.
- 10 anni fa, avrei accettato lo spazio sullo schermo. Oggi utilizzo uno schermo 1920 * 1200. Si adatta a MOLTO codice, più di quanto il mio cervello possa elaborare contemporaneamente. Il primo metodo mi consente di tornare indietro e vedere il diverso ambito di apertura / chiusura senza doverlo leggere.
- Non sono mai riuscito a capire perché ho preferito questo metodo, ma ' è esattamente questo.
- @Mageek Questo è tardivo, ma ' non sono due righe, ' s 2 righe per ogni ambito. Quello ' è O (N), non O (1). Non ' in realtà la penso così forte; è ' più importante che tu scelga uno stile che renda leggibili lunghi elenchi di parametri.
Risposta
Preferisco il primo metodo. Le parentesi graffe non valgono una riga separata.
Il fatto è che le parentesi graffe non sono importanti. Sono “solo cestino sintattico , che non è assolutamente necessario per capire a cosa serve il codice, il suo scopo e il il modo in cui è implementato. Sono solo un tributo ai linguaggi C-like vecchio stile in cui il raggruppamento visivo degli operatori era impossibile a causa dello spazio disponibile sullo schermo ridotto.
Ci sono linguaggi (Python, Haskell, Ruby) che vanno bene anche senza parentesi graffe. Questo conferma solo che le parentesi graffe sono spazzatura e non dovrebbero meritare una riga per loro quando possibile:
if (you.hasAnswer()){ you.postAnswer(); }else{ you.doSomething(); }
Commenti
- Non ' non so niente di Haskell o Ruby, ma Python è sensibile agli spazi, motivo per cui ' non richiede parentesi graffe o altri delimitatori per indicare i blocchi. Le parentesi graffe non sono solo rumore sintattico; servono a uno scopo reale.
- @Robert, In C devi fare sia spazi e parentesi graffe. In Python dovresti fare solo spazi bianchi. Quale è meglio?
- @Pavel, in C ' non ' non devi fare lo spazio bianco.
- I programmi C @KenBloom senza spazi sono impossibili da leggere. Quindi devi farlo comunque.
- Indipendentemente dal fatto che le parentesi graffe siano una buona idea o meno, la mera esistenza di linguaggi che non ' non le usa ' non sembra un argomento a favore o contro di loro. Suggerisce solo che è possibile avere una lingua senza di loro, non che si tratti di un linguaggio di progettazione buono o cattivo.
Risposta
Usa Python e aggira completamente largomento.
Commenti
- +1
SyntaxError: not a chance
- Questa semplicemente non è unopzione per la stragrande maggioranza dei progetti. Inoltre, lindentazione per il raggruppamento ha una ' quota di problemi.
- @Bryan, mi rendo conto che questo non è ' t molto pratico. Ho solo pensato che fosse un punto di vista che doveva essere là fuori, più forte di un semplice commento. E io ' non ho mai incontrato i problemi causati dal rientro che tu implichi, probabilmente perché non ' mescolare tabulazioni e spazi.
- Usa Vai ed elude completamente largomento (più digitazione statica, velocità e un compilatore!) 🙂
- Quindi premi la barra spaziatrice una troppe volte e guarda il compilatore / interprete ridere a te. Ciò ' non accadrà nella maggior parte delle lingue.
Rispondi
La posizione delle parentesi graffe deve essere
metadati
configurabile nellIDE dal programmatore. In questo modo, quelle fastidiose parentesi graffe in tutto il codice, indipendentemente dallautore, hanno lo stesso aspetto.
Commenti
- Totalmente daccordo. È ' una presentazione e non dati.
- Il problema è che se lasci che tutti impostino le proprie, le cose si complicano molto rapidamente man mano che vengono eseguiti i commit.
- @Andy: Questo ' è esattamente il punto, lIDE cambierà il loro aspetto, ma solo nellIDE! La sorgente effettiva non verrà toccata. Per il controllo della versione, puoi aggiungere hook che traducono qualunque fosse limpostazione per le parentesi graffe in una situazione comune, in modo che tutti controllino il codice allo stesso modo.
- @klaar Ogni IDE moderno i ' utilizzato cambierà le tabulazioni in spazi e sposterà le parentesi graffe sulla propria riga o alla fine dell " apertura " linea; ' non sono sicuro del motivo per cui pensi che la fonte non sia ' toccata in questi casi, e questo è il motivo del mio commento. È tipicamente modificato dagli IDE a seconda delle impostazioni degli sviluppatori, il che significa che durante un commit ' vedrò molti cambiamenti che sono solo rumorosi quando le parentesi graffe vengono spostate sulla loro riga, nascondendo così la modifica EFFETTIVA che qualcuno ha fatto.
- @ Andy: Non è ' cè la possibilità di utilizzare hook che convertono quelle discrepanze riguardanti spazi bianchi e parentesi graffe in uno standard uniforme uppon commit, per aggirare il problema di rumore che hai descritto? In ogni caso, un corretto sistema di controllo delle versioni dovrebbe trascendere cose meschine come spazi bianchi o altre cose senza senso.
Risposta
Preferisco il primo perché è più difficile per me vedere lerrore in questo esempio.
if (value > maximum); { dosomething(); }
rispetto a questo esempio
if (value > maximum); { dosomething(); }
; {
mi sembra più sbagliato di una riga che termina con ;
quindi sono più propenso a notarlo.
Commenti
- Fai un buon argomento, ma personalmente, questo ha sempre mi è successo una volta nei miei 5 anni di programmazione. Non sono riuscito ' a capire perché ' non veniva eseguito, lho pubblicato su SO e qualcuno mi ha subito indicato il punto e virgola. Tuttavia, ogni volta che viene condensato per utilizzare quella riga in meno, trovo più difficile da leggere.
- Il "; {" ha laspetto di un file tipo di faccia ammiccante scontrosa o forse una persona con i baffi.
- +1 Ottimo esempio nella risposta: errore molto sottile, facilmente trascurato. Ho pensato di provocare anche il layout che lo mostra.
- Ovviamente qualsiasi IDE decente contrassegnerà listruzione di controllo vuota e qualsiasi compilatore decente emetterà un avviso.
- @Dunk Lunico difetto nel tuo largomento (con il quale sono decisamente daccordo) è che così tante persone usano linguaggi interpretati oggigiorno (JavaScript, PHP e altri) che molti " programmatori " ' non riconoscerebbe un compilatore da un doppio latte.
Risposta
Dipende.
Se sto codificando in Javascript o jQuery, utilizzo la prima forma:
jQuery(function($) { if ($ instanceOf jQuery) { alert("$ is the jQuery object!"); } });
Ma se sto codificando in C #, utilizzo la seconda forma, perché questo è il modo canonico per farlo in C #.
public int CalculateAge(DateTime birthDate, DateTime now) { int age = now.Year - birthDate.Year; if (now.Month < birthDate.Month || (now.Month == birthDate.Month && now.Day < birthDate.Day)) age--; return age; }
Nota che il tuo esempio può essere scritto
if (you.hasAnswer()) you.postAnswer(); else you.doSomething();
in C #.
Commenti
- Può essere scritto in molte lingue in questo modo, perché unistruzione di blocco è una dichiarazione. Aggiunta! 🙂
- Secondo le " Linee guida per la progettazione del framework " le " Il modo canonico " consiste nel posizionare la parentesi graffa di apertura sulla stessa riga (cioè la prima forma). Dì solo ' …
- @Uwe: forse. Ma Microsoft ha adottato lapproccio " parentesi graffe allineate " per tutti i suoi esempi C # di MSDN e ' è integrato in Visual Studio, quindi …
- @Uwe: That ' s Cwalina ' s libro ed è ' terribilmente chiamato perché è molto di più. LFDG su MSDN non ha nulla da dire al riguardo. Inoltre mi chiedo, perché le linee guida del Framework Design direbbero qualcosa sulla pratica di C # codifica ?
- Dovresti, infatti, mettere le parentesi graffe sulla stessa riga in Javascript. È possibile causare errori se le parentesi graffe si trovano sulla propria riga. Ad esempio, vedi encosia.com/…
Risposta
Preferisco una leggera variante di 1)
if (you.hasAnswer()) { you.postAnswer(); } // note the break here else { you.doSomething(); }
Perché?
-
Penso che sempre mettere le parentesi graffe sulla propria riga diminuisca la leggibilità. Posso inserire solo una certa quantità di codice sorgente sul mio schermo. Lo stile parentesi 2) rende gli algoritmi di sollevamento con molti cicli annidati e condizionali estremamente lunghi.
-
Tuttavia, voglio che
else
inizi su una nuova riga perchéif
eelse
appartengono visivamente. Se cè “una parentesi davanti aelse
, è molto più difficile individuare cosa appartiene a cosa. -
3 ) si squalifica. Sappiamo tutti quali brutte cose possono accadere se ometti le parentesi e ti dimentichi.
Commenti
- Lho visto in giro dove lavoro. È ' interessante.
- Anche questo stile mi piace di più, poiché mi consente di inserire un commento sopra
else
riga quando necessario e / o inserire una riga vuota tra il blocco if e il blocco else per far sembrare le cose meno stipate. Lo stile di parentesi # 2 non fa altro che distanziare le azioni dalle condizioni. Detto questo, il mio preferito è sicuramente python ' s senza stile parentesi 🙂 - Se massimizzare il numero di righe di codice sullo schermo è importante, allora basta farla finita con le nuove righe del tutto. ' potrai visualizzare molte righe su una schermata. Preferisco non avere nulla che mi faccia fermare e pensare durante la lettura, ad es. la mia definizione di più leggibile. Con le parentesi graffe la mia mente le ignora. Senza le parentesi graffe la mia mente deve mettere in pausa e allineare i blocchi di controllo. Non una lunga pausa, ma comunque una pausa.
- Sì, se e gli altri appartengono insieme, MA così fai {e} e come} è su una riga separata, {dovrebbe essere su una riga separata anche la linea. " Posso inserire solo una certa quantità di codice sorgente sullo schermo " E questo ' È esattamente il motivo per cui dire 3) sarebbe " squalificarsi " non è affatto unopzione. Dopo un decennio di lavoro con 3) non ho dimenticato di aggiungere parentesi quando si aggiunge una nuova riga di codice, mai, né conosco nessuno che abbia mai avuto. Se devo adattare il codice alle persone, chi può ' leggere correttamente, dove finisce? Smetti di utilizzare determinate funzioni linguistiche, perché alcuni lettori di codici potrebbero non capirle?
Risposta
Ho letto da qualche parte che gli autori di qualche libro volevano che il loro codice fosse formattato in questo modo:
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
Ma i vincoli di spazio del loro editore significavano che dovevano usare questo:
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
Ora non so se sia vero (perché non riesco più a trovarlo), ma questultimo stile è molto diffuso nei libri.
A livello personale preferisco le parentesi riga separata come:
a) indicano un nuovo ambito
b) è più facile individuare quando si ha una mancata corrispondenza (sebbene questo sia un problema minore in un IDE che evidenzia gli errori per te).
Commenti
- … La seconda opzione facilita anche entrambi i tuoi punti (con il solo rientro che serve allo scopo della parentesi graffa / indentazione combo). 🙂
Risposta
Ah, il One True Brace Style .
Ha tutto il necessario per un Holy W ay – persino un profeta (Richard “a modo mio o in autostrada” Stallman).
Il tipo aveva torto su così tante cose, ma GNU è perfetto quando si tratta di parentesi graffe.
[Aggiornamento] Ho visto la luce e ora adoro Allman
Commenti
- Non ' per vedere il punto dello stile GNU, a parte il fatto che modella il codice lisp. Sembra che si lavori molto con pochi vantaggi.
- Non conosco nessuno che usi lo stile GNU. 1 TB fino in fondo.
- Non puoi ' fare peggio di due livelli di rientro per blocco, tranne che per lo stile lisp, ovviamente, questo è ovvio.
- +1 per il collegamento sugli stili delle parentesi graffe. Mostra che qualunque sia il tuo stile, molte persone fantastiche non sono daccordo con te.
- @RobertHarvey Non cè lavoro extra, se lo è, non ' usi il strumento giusto per scrivere codice o configurarlo correttamente. Il vantaggio è un codice molto più leggibile, vedi ogni errore tra parentesi molto velocemente e puoi leggere facilmente solo il codice mentre ignori i sottoblocchi.
Risposta
Secondo esempio, sono molto bravo in fatto di leggibilità. Non sopporto “se si blocca in altro modo = (
Commenti
- La ricerca indica che ' è un codice compatto più facile da leggere una volta che una base di codice supera laltezza dello schermo.
- @ weberc2 , potresti fornire DOI a questi documenti di ricerca?
Risposta
Risposta semplice: cosè più facile eseguire il debug?
// Case 1: void dummyFunction() { for (i = 0; i != 10; ++i) { if (i <= 10) std::cout << "i is: " << i << "\n"; std::cout << 10 - i << " steps remaining\n"; // Some hard work here // which is really hard // and does take some screen estate } else std::cout << "We"ll never get there"; } } // COMPILER ERROR HERE // Case 2: void dummyFunction() { for (i = 0; i != 10; ++i) if (i <= 10) { std::cout << "i is: " << i << "\n"; std::cout << 10 - i << " steps remaining\n"; // Some hard work here // which is really hard // and does take some screen estate } else std::cout << "We"ll never get there\n"; } } // COMPILER ERROR HERE
In quale caso hai diagnosticato prima il problema?
Non mi interessano molto le preferenze personali (ce ne sono molte altre stili, inclusi whitesmith e altri) e non mi interessa molto … fintanto che non ostacola la mia capacità di leggere il codice e eseguire il debug it.
A s allargomento “spreco di spazio”, non lo compro: tendo comunque ad aggiungere righe vuote tra i gruppi logici per rendere il programma più chiaro …
Commenti
- Sono entrambi altrettanto facili da eseguire il debug, principalmente poiché ' è un breve blocco di codice. Il rientro è coerente, rendendo facile visualizzare i blocchi di codice effettivi.
- @Htbaa: infatti 🙂 Allora perché preoccuparsi?
- @MatthieuM. Il primo blocco ha più senso per me, perché le nuove righe (nel secondo blocco) tra la firma della funzione, listruzione for e listruzione if mi fanno credere che non siano correlate, ma chiaramente non sono ' t. Le righe vuote servono per separare i bit di codice non correlati; il codice che ' è vicino ad altre righe di codice significa che sono effettivamente correlate. Naturalmente è tutto ' imo ', ma mi chiedevo quale fosse il tuo punto di vista. EDIT: anche qualsiasi IDE appropriato noterà la mancanza di parentesi graffe e ti darà uninfarinatura di errori nellinterpretazione del tuo codice.
- Vorrei sottolineare che queste due sezioni di codice sono completamente diverse. Avresti errori del compilatore in diversi punti del codice. Il primo avrebbe un errore del compilatore su " else " e lultimo curly. Il secondo avrebbe solo un errore del compilatore sullultimo riccio.
Risposta
Non che nessuno se ne accorgerà, ma questo è il motivo per cui le parentesi graffe appartengono alla stessa riga del condizionale (eccetto per i condizionali molto lunghi, ma questo è un limite case):
In C, questo è un costrutto valido:
while(true); { char c; getchar(); //Wait for input }
Veloce! Cosa fa questo codice? Se hai risposto ” ciclo infinito che chiede input “, ti sbagli! Non arriva nemmeno allinput. Viene rilevato in while(true)
. Notare quel punto e virgola alla fine.Questo modello è in realtà più comune di quanto sembra dovrebbe essere; C richiede che tu dichiari le tue variabili allinizio di un blocco, motivo per cui ne è stato avviato uno nuovo.
Una riga di codice è un pensiero. Le parentesi graffe sono una parte del pensiero che contiene il condizionale o il ciclo. Pertanto, appartengono alla stessa riga.
Commenti
- Questo è di gran lunga largomento migliore per lo stile K & R che ho visto, il resto è ridicolo con oggi ' s sistemi IDE con supporto per piegatura codice. Questo si applica solo ai linguaggi in stile C che supportano
;
blocco finale. Questo è anche il motivo per cui disprezzo questo sistema di chiusura a blocchi che IMHO è obsoleto e il linguaggio Go lo dimostra. Ho visto questo problema molte volte anche se non in questo scenario. Di solito accade dove intendono aggiungere qualcosa allistruzione e dimenticarsene.
Risposta
Mi piace primo metodo. Sembra più ordinato IMO, ed è più compatto, il che mi piace.
EDIT: Ah, un terzo. Mi piace quello il meglio quando possibile, perché è ancora più piccolo / più ordinato.
Risposta
Potresti scriverla:
you.hasAnswer() ? you.postAnswer() : you.doSomething();
A rispondi alla domanda; Preferivo le parentesi graffe sulla propria riga, ma, per evitare di dover pensare a bug derivanti dallinserimento automatico del punto e virgola nei browser, ho iniziato a utilizzare lo stile egiziano per javascript. E quando codificavo java in eclipse non avevo alcun interesse a combattere (o configurare) lo stile di parentesi graffa predefinito, quindi sono andato con Egyptian anche in quel caso. Ora sto bene con entrambi.
Commenti
- da usare in questo modo,
postAnswer()
edoSomething()
dovrebbe restituire il valore per loperatore ternario, il che spesso non è il caso: possono benissimo restituire void (nessun valore). e anche (almeno in c #) risultato di?:
dovrebbe essere assegnato a qualche variabile
Risposta
Quasi tutte le risposte qui stanno dicendo alcune variazioni su “Qualunque cosa tu faccia, mantieni uno o due”.
Quindi ci ho pensato per un momento e ho dovuto ammettere che non lo vedo come così importante . Qualcuno può dirmi onestamente che quanto segue è difficile da seguire?
int foo(int a, Bar b) { int c = 0; while(a != c) { if(b.value[a] == c) { c = CONST_A; } c++; } return c; }
Non sono sicuro di qualcun altro … ma ho assolutamente zero problemi mentali passare avanti e indietro tra gli stili. Mi ci sono voluti alcuni istanti per capire cosa faceva il codice, ma questo è il risultato della mia digitazione casuale della sintassi tipo C. 🙂
A mio parere non così modesto, aprire le parentesi graffe è quasi completamente irrilevante per la leggibilità del codice. Ci sono alcuni casi dangolo sopra elencati in cui uno stile o laltro fa la differenza, ma per la maggior parte, un uso giudizioso di righe vuote lo ripulisce.
FWIW, i nostri stili di codifica al lavoro usano un po forma 1 più strutturata e una forma modificata 3. (C ++)
// blank line is required here if (x) { //This blank line is required y = z; } // blank line is required here too, unless this line is only another "}" if (x) y = z; //allowed if (x) y = z; // forbidden
Sono curioso di sapere se coloro che preferiscono fortemente la forma 2 troverebbero questa versione della forma 1 meglio, solo perché la riga vuota offre una separazione visiva più forte.
Commenti
- Come mostra il tuo esempio, il rientro è molto importante delle parentesi graffe per essere leggibile In effetti, alcuni linguaggi rendono il rientro il solo modo di annidare le istruzioni!
- Ok, onestamente trovo che il tuo esempio incoerente sia difficile da leggere. Non DAVVERO difficile, ma più difficile di se era coerente.
- Sono daccordo con Almo. Non è un caso di " è davvero difficile " . È un caso di " è decisamente più difficile ", anche se non difficile. Allora perché rendere le cose più difficili? Negli esempi di " toy " forniti dalle persone ovviamente cè poca differenza. Nella mia esperienza, quando eredito codice cattivo da qualcun altro e hanno usato il metodo 1, abbastanza spesso diventa necessario andare avanti e trasformarlo in metodo 2 solo per poter seguire la logica. A causa del fatto che diventa spesso necessario; risponde automaticamente alla domanda su quale metodo sia migliore e più facile da capire.
- @Dunk: non riesco a capire il codice che sarebbe notevolmente migliorato scambiando dettagli così irrilevanti.
- @jkerian -Apparentemente non hai ' ereditato molto codice da altri che hanno lasciato da tempo il progetto o lazienda. Riesco ' a non incappare in quella situazione da chiunque abbia alcuni anni di esperienza. Ma poi di nuovo, la situazione lavorativa di tutti ' è diversa. Inoltre, se devi eseguire " " revisione del codice formale, la formattazione fa la differenza. Essere in grado di leggere il codice naturalmente è molto importante.Certo posso fermarmi e pensare di abbinare le parentesi graffe, ma questo rallenta il processo. Un modo non richiede una pausa, gli altri sì. Questo ' è il motivo per cui ' non vedo perché potrebbe essere consigliata qualsiasi altra scelta.
Risposta
Sono sorpreso che questo non sia stato ancora sollevato. Preferisco il secondo approccio perché ti permette di selezionare il blocco più facilmente.
Quando le parentesi graffe iniziano e finiscono sulla stessa colonna e sulla propria riga, puoi selezionare dal margine o con il cursore sulla colonna 0. Ciò generalmente equivale a unarea più generosa con la selezione del mouse o meno sequenze di tasti con selezione da tastiera.
Inizialmente lavoravo con le parentesi graffe sulla stessa riga del condizionale, ma quando ho cambiato ho scoperto che ha accelerato la velocità con cui ho lavorato. Ovviamente non è notte e giorno, ma è qualcosa che ti rallenta leggermente quando lavori con le parentesi graffe accanto ai tuoi condizionali.
Commenti
- I veterani come me usano tre sequenze di tasti per selezionare il blocco, indipendentemente da dove siano le dannate parentesi graffe.
Rispondi
Personalmente mi piace il secondo modo.
Tuttavia, il modo in cui intendo dimostrare è secondo me il migliore perché si traduce in una maggiore sicurezza sul lavoro! Un compagno di studi della mia università mi ha chiesto aiuto per i compiti e questo è laspetto del suo codice. Lintero programma sembrava un unico blocco. La cosa interessante è che il 95% dei bug nel programma che ha creato provenivano da parentesi graffe non corrispondenti. Laltro 5% era ovvio una volta che le parentesi graffe venivano abbinate.
while(1){ i=0; printf("Enter coded text:\n"); while((s=getchar())!="\n"){ if(i%1==0){ start=(char*)realloc(input,(i+1)*sizeof(char)); if(start==NULL){ printf("Memory allocation failed!"); exit(1);} input=start;} input[i++]=s;} start=(char*)realloc(input,(i+1)*sizeof(char)); if(start==NULL){ printf("Memory allocation failed!!!"); exit(1);} input=start; input[i]="\0"; puts(input);
Commenti
- Cattivo, cattivo , Voglio dire terribile, terribile esempio. Il problema non sono le parentesi graffe! È ' il rientro folle!
- @Martinho Fernandes Pensavo che il posizionamento di parentesi graffe e rientranza vadano insieme …
- non necessariamente. .. esegui il rientro corretto su quanto sopra e poi cambia in modo casuale gli stili delle parentesi graffe, ' scoprirai che ' è comprensibile.
- In effetti, pensare a questo ha motivato la mia risposta a questa domanda.
- " Il 95% dei bug nel programma che ha creato proveniva da parentesi graffe non corrispondenti " – solo nelle lingue interpretate, non compilate.
Risposta
La mia preferenza personale è per il primo metodo, probabilmente perché “è il modo in cui ho imparato PHP per la prima volta.
Per le istruzioni if
a riga singola, Userò
if (you.hasAnswer()) you.postAnswer();
Se non è you.postAnswer();
ma qualcosa di un molto più a lungo, ad esempio you.postAnswer(this.AnswerId, this.AnswerText, this.AnswerType);
probabilmente tornerò alla fi primo tipo:
if (you.hasAnswer) { you.postAnswer(this.AnswerId, this.AnswerText, this.AnswerType); }
Non userò mai uninterruzione di riga e non userò mai questo metodo se cè anche un else
.
if (you.hasAnswer()) you.postAnswer(); else you.doSomething()
è una possibilità teorica, ma non una che avrei mai usato. Questo dovrebbe essere trasformato in
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
Risposta
Non dovrebbero; primo metodo per me.
Quando guardo il secondo, a causa delle linee inutilizzate (quelle che hanno solo le parentesi graffe, a parte lultima parentesi graffa di chiusura), sembra che interrompa la continuità di il codice. Non posso “leggerlo velocemente perché ho bisogno di prestare particolare attenzione alle righe vuote che di solito significano una separazione nello scopo del codice o qualcosa del genere, ma in nessun caso” questa riga appartiene a una parentesi graffa “(che ripete solo il significato di rientro).
Comunque, proprio come quando scrivi del testo … laggiunta di un rientro allinizio di un paragrafo è superfluo se cè una riga vuota prima di essa (doppio segno di cambio di paragrafo), lì non è necessario sprecare righe per parentesi graffe quando indentiamo correttamente.
Inoltre, come già affermato, consente di inserire più codice nello schermo, il che altrimenti è un po controproducente.
Risposta
Dipende dalla piattaforma / lingua / convenzioni
In Java:
void someMethod() { if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); } }
In C #
void someMethod() { if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); } }
In C:
void someMethod() { if (you_hasAnswer()) { you.postAnswer(); } else { you_doSomething(); } }
Odio quando i ragazzi di Java usano il loro stile nel codice C # e viceversa.
Commenti
- Lo stile C al modi mi infastidivano. Sii coerente!
Rispondi
Tutto quello che posso dire è che se sei un fan del metodo n. 3 , sarai perseguitato da ogni formattatore di codice IDE sulla terra.
Risposta
Uso il primo metodo semplicemente perché è più compatto e consente più codice sullo schermo. Io stesso non ho mai avuto problemi con lassociazione delle parentesi graffe (le scrivo sempre, insieme allistruzione if
prima di aggiungere la condizione e la maggior parte degli ambienti consente di passare alla parentesi graffa corrispondente).
Se hai bisogno di accoppiare visivamente le parentesi graffe, preferirei il secondo metodo. Tuttavia, ciò consente meno codice alla volta, il che richiede di scorrere di più. E questo, almeno per me, ha un impatto maggiore sulla lettura del codice rispetto alle parentesi graffe ben allineate. Odio scorrere. Poi di nuovo, se è necessario scorrere una singola istruzione if
, è molto probabile che sia troppo grande e necessita di refactoring.
Ma; la cosa più importante di tutte è la coerenza. Usa luno o laltro, mai entrambi!
Rispondi
Quando stavo imparando la programmazione a 12 anni, ho messo le parentesi graffe la riga successiva perché i tutorial di codifica Microsoft sono così. Quella volta ho anche rientrato con TAB di 4 spazi.
Dopo alcuni anni, ho imparato Java e JavaScript e ho visto più parentesi graffe sulla stessa riga del codice, quindi ho cambiato. Ho anche iniziato a rientrare con SPAZI di 2 spazi.
Commenti
- +1, -1. Perché NON dovresti rientrare con le tabulazioni poiché qualsiasi editor può regolare la lunghezza della tabulazione in base alla tua lunghezza arbitraria? Altrimenti, induci molti di noi a cui piacciono i veri trattini all8 a maledire il tuo codice.
Rispondi
Cè una quarta opzione che mantiene le parentesi graffe allineate, ma non spreca spazio:
if (you.hasAnswer()) { you.postAnswer(); i.readAnswer(); } else { you.doSomething(); }
Lunico problema è che la maggior parte degli autoformattatori IDE soffocano su questo.
Commenti
- … come la maggior parte dei programmatori che soffocerebbero con questo.
- Sembra orrendo. Pensa al sforzo extra che devi compiere se desideri inserire una riga in alto o rimuovere la riga in alto. Puoi ' semplicemente eliminare la riga e andare avanti, devi ricordare per reinserire la parentesi graffa.
- lol è fantastico! 🙂 meglio del primo stile!
- A quanto pare ha anche un nome. Horstman Syyle è menzionato in wikipedia . ' ho lavorato con una base di codici come questo, ' non è male utilizzare.
Risposta
Dipende tutto da te finché non lavori a un progetto in cui alcuni vincoli di codifica o alcuni standard sono stati stabiliti dal project manager che tutti i programmatori che stanno lavorando a quel progetto devono seguire durante la codifica.
Personalmente preferirei il primo metodo.
Inoltre non ho ottenuto quello che vuoi mostrare con il terzo metodo?
Non è un modo sbagliato? Ad esempio, considera una situazione come ..
if (you.hasAnswer()) you.postAnswer(); else you.doSomething();
E se qualcuno volesse aggiungere altre dichiarazioni nel if block?
In tal caso, se utilizzi il terzo metodo, il compilatore genererà lerrore di sintassi.
if (you.hasAnswer()) you.postAnswer1(); you.postAnswer2(); else you.doSomething();
Commenti
- Anche peggio sarebbe se qualcuno arrivasse e lo facesse: if (you.hasAnswer ()) you.postAnswer (); altro you.doSomething (); you.doSomethingElse (); – è ' una ricetta per bug sottili su cui locchio può facilmente scivolare e il compilatore non ha ' aiutato
- @FinnNk: Esatto!
- Se qualcuno vuole aggiungere unaltra dichiarazione, può mettere le parentesi graffe. Qualsiasi programmatore degno di questo nome dovrebbe davvero essere in grado di capirlo.
- Volevo dire che il suo terzo metodo è sbagliato.
- @Robert Harvey, io ' abbiamo visto programmatori molto esperti perdere le parentesi graffe durante la modifica del codice esistente. Penso che il problema sia che lindentazione è un indizio molto più forte del significato rispetto alle parentesi graffe (soprattutto perché ci sono più stili di parentesi graffe), quindi ' è abbastanza facile trascurare la parentesi graffa mancante se il il rientro è quello che ti aspetti.
Lascia un commento