Come seguire la best practice per il limite di 80 caratteri durante la scrittura del codice sorgente?

Quindi, come sapete, esiste un detto delle migliori pratiche

Limitare una riga di codice sorgente in 80 caratteri.

Ecco 2 link:

Perché 80 caratteri sono il limite 'standard' per la larghezza del codice?

Il limite di 80 caratteri è ancora rilevante in tempi di monitor widescreen?

E sono sicuro che puoi cercare di più se cerchi questa best practice.

Ma lo trovo estremamente difficile, ecco un esempio di esempio:

public class MyClass {

    public void myMethod() {

        final Map<String, List<MyInterfaceHere>> myReference

Quindi indentate ogni classe, ogni metodo e ogni istruzione.

E sono già alla colonna 60 entro la fine dell'ultima "e" che ho in "myReference".

Mi restano 20 spazi per chiamare il costruttore e assegnare l'oggetto al riferimento che ho.

Voglio dire, sembra davvero migliore:

public class MyClass {

    public void myMethod() {

        final Map<String, List<MyInterfaceHere>> myReference 
                = new HashMap<String, List<MyInterfaceHere>>(); 

Qual è la migliore pratica qui?

La migliore pratica dovrebbe essere "limitare la lunghezza di una linea in modo che tu, tutti i tuoi colleghi e tutti gli strumenti che stai utilizzando ne sia soddisfatto", oltre ad un po 'di buon senso. 80 caratteri sembrano essere molto bassi e tendono a ridurre la leggibilità. Una volta sono stato completamente ingannato da una linea come questa:

/* Very long comment to the end of the line */ realCode ();

dove la chiamata di funzione non era visibile sullo schermo (né era visibile sullo schermo di nessun collega) senza alcuna indicazione.

Ho impostato il mio editor per visualizzare un margine di 100 colonne, oltre a ri-avvolgere il codice sul display, quindi tutto è sempre visibile durante la modifica e le righe troppo lunghe tendono a essere divise manualmente in due o talvolta più righe. Prega che il tuo editor formatta correttamente le istruzioni se esegue la formattazione automatica. Utilizzare uno stile di codifica che non porta a istruzioni profondamente nidificate. (Alcune persone creano un nido di venti dichiarazioni if ​​seguite da una coda di venti altre che porta a un rientro profondo di 200 caratteri, e nessuno può capire a quale altro appartiene a quale se).

Nel tuo caso particolare, Swift ha inventato un modo per evitarlo: una variabile "let" (che è quasi uguale a "final" in altre lingue) deve essere assegnata un valore esattamente una volta prima di essere utilizzata, ma non necessariamente nella dichiarazione , quindi potresti dividere la tua linea problematica in due affermazioni indipendenti.

PS. Ho incontrato righe, in vero codice scritto da umani, di oltre 400 caratteri. In altre parole, dovresti scorrere per anni per leggere il resto della linea, anche su un monitor da 24 pollici. Non ero divertito :-(

Sì, sembra migliore. Ecco perché il "Non usare linee troppo lunghe!" la massima è così molto forte.

Per quanto riguarda le migliori pratiche, non uso mai e poi mai queste espressioni orribilmente lunghe di costruttori. Vorrei sempre usare

public class MyClass {

    public void myMethod() {

        final Map<String, List<MyInterfaceHere>> yReference = newMap();

per alcuni valori opportunamente definiti, importati staticamente di newMap(). Lo considero un grave difetto in Java che non ha una versione integrata.

L'obiettivo non è "mantenere le righe fino a 80 caratteri". L'obiettivo è "rendere il tuo codice facile da leggere e comprendere". Il limite di 80 caratteri artificiali aiuta nella leggibilità, ma non è una regola rigida e veloce a meno che la tua squadra non lo decida.

Hai chiesto la migliore pratica e la migliore è "concentrarsi sul rendere il codice il più leggibile possibile". Se ciò richiede più di 80 caratteri, così sia.

Non aver paura di premere il tasto Invio. La maggior parte dei linguaggi moderni (incluso Java come nel tuo esempio) sono abbastanza contenti delle affermazioni che corrono su più righe.

Basti pensare a dove spezzare le linee e puoi ottenere qualcosa che si adatta a un limite di 80 colonne e rimane comunque perfettamente leggibile. Le convenzioni ufficiali di codifica Java specificano persino i luoghi preferiti per interrompere le linee.

Fatto a destra, una linea ben suddivisa è molto più leggibile di una che scompare dal lato dello schermo.

Se si applica la lunghezza della linea / larghezza del codice, utilizzare uno strumento.

• ReSharper
• Visual Assist
• eccetera.

Gli sviluppatori decidono quale sia una lunghezza ragionevole (80, 120, 200, ecc.), Impostando tale opzione nello strumento.

Dopodiché, scrivi il codice come faresti normalmente, indipendentemente da quanto sia lunga o lunga la linea. Una volta che è funzionante e finito, fai clic con il tasto destro e scegli Clean Up Code o un'opzione simile. Lo strumento formatterà il codice come indicato e spezzerà le righe lunghe come indicato.

Insensato e facile e ogni file sorgente verrà formattato allo stesso modo.

Il limite di 80 caratteri potrebbe essere un po 'troppo breve in questi giorni, ma aiuta. Concordo con tutte quelle opinioni sul fatto che anche il codice dovrebbe essere ben formattato. ad es. codice

/ * Commento molto lungo fino alla fine della riga * / realCode ();

può essere all'interno di 80 chr ma crea confusione poiché le osservazioni e le opzioni del codice sono sulla stessa riga singola.

Adottare il limite di 80 chr o meno è una scelta degli individui, ma se le cose sono visibili in uno scatto singolo, darà sempre una visione e una sensazione confortevoli anche ai programmatori e agli altri revisori.