IntelliJ IDEA: stile di codifica e formattazione del codice

Un linguaggio di programmazione è molto simile a una lingua parlata. L'unica differenza è che si tratta di un linguaggio speciale il cui scopo principale è facilitare la comunicazione con un computer per spiegare al computer cosa vogliamo che faccia. Ma non puoi avere una conversazione personale con un computer. Quando hai iniziato a imparare un linguaggio di programmazione, hai guardato libri o qualche risorsa educativa come CodeGym. E questa risorsa ti ha mostrato un codice che il computer comprende. Ma anche tu dovresti capirlo mentre impari a conoscere il linguaggio Java. Come con qualsiasi linguaggio, nella programmazione sono state adottate alcune convenzioni di formattazione. Ad esempio, in una società educata, scrivere in questo modo sarebbe considerato una cattiva educazione. E in Java, iniziare il nome di un metodo con una lettera maiuscola è una grave violazione delle convenzioni di codifica. Le regole per il codice Java sono fornite nel documento Code Conventions for the Java Programming Language . Le convenzioni di codifica possono anche regolare dettagli più piccoli, come l'indentazione. Immagina l'incubo totale che il controllo della versione diventerebbe se il rientro fosse incoerente, alcune persone usassero le schede e altre persone usassero gli spazi. Come sarebbe per qualcuno che ha bisogno di archiviare una correzione in un solo metodo, ma trova l'intero file modificato a causa delle differenze negli spazi e nelle schede? Naturalmente, come con il linguaggio ordinario, le convenzioni possono cambiare a seconda di dove viene utilizzata una lingua. Ad esempio, nelle vaste distese del Web, puoi trovare la Google Java Style Guide e la Twitter Java Style Guide. Per questa recensione, abbiamo bisogno di un soggetto di prova. Useremo il sistema di automazione della build Gradle. Ci consentirà di iniziare rapidamente creando un nuovo progetto da un modello. Gradle ha un ottimo plugin: Build Init Plugin . Andiamo in una nuova directory ed eseguiamo il seguente comando: gradle init --type java-application Successivamente, avvia IntelliJ IDEA. Se vedi una finestra con un progetto aperto (cioè vedi l'editor di codice e l'albero del progetto), chiudi questo progetto usando File -> Close Project. Ora nella finestra di benvenuto, esegui " Import Project" e importa il nostro nuovo progetto. Durante l'importazione, imposta la Use autoimportcasella di controllo " ". Scopriamo se possiamo utilizzare strumenti di sviluppo all'avanguardia per semplificare in qualche modo la vita.

Formattazione del codice in IDEA

Dopo aver importato il progetto, premi Ctrl+N e vai alla AppTestclasse. Questa è la classe di test predefinita. Sembra così:

 import org.junit.Test;
 import static org.junit.Assert.*;
 
 public class AppTest {
     @Test public void testAppHasAGreeting() {
         App classUnderTest = new App();
         assertNotNull("app should have a greeting", classUnderTest.getGreeting());
     }
 }

Cosa salta subito all'occhio? Un'annotazione sulla stessa riga di una dichiarazione di metodo, che sembra brutta, giusto? Come risolvere questo problema? IntelliJ IDEA ha una Codevoce di menu " " per varie manipolazioni del codice. Una di queste manipolazioni è " Reformat Code", che puoi applicare usando Ctrl+L. Dopo aver eseguito questa operazione, l'annotazione sarà su una riga e la dichiarazione del metodo su un'altra. Vale la pena notare subito che questa operazione viene eseguita sul codice attualmente selezionato . Se non c'è selezione, l'operazione di formattazione viene eseguita su tutto. Ora aggiungiamo un nuovo metodo di test:

 @Test
 public void testSumOfOddNumbers() {
 	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
 	Integer result = data.stream().filter(number -> number % 2 == 0).reduce((n1, n2) -> n1 + n2).get();
 	assertThat(result, is(12));
 }

E due importazioni:

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

Come puoi vedere, l'operazione sullo Stream è su una riga. Ma cosa succede se vogliamo assicurarci che le chiamate al metodo concatenate siano sempre suddivise in nuove righe per ogni operatore di periodo? Potremmo farlo manualmente. Ma ricorda che vogliamo che tutto avvenga automaticamente. In effetti, di tanto in tanto dimenticheremo sicuramente il passaggio manuale, e poi ci ritroveremo con una formattazione diversa ovunque, e non va bene. Quindi dobbiamo modificare la regola che IDEA utilizza per la formattazione. ScegliereFile -> Settingsnel menu IDEA (o premere Ctrl+Alt+S). Immettere "Stile codice" nel campo di ricerca nella finestra delle impostazioni. Nella sezione "Stile codice", puoi specificare le impostazioni per più linguaggi oltre a Java. Ma Java è ciò che ci interessa in questo momento. Come puoi vedere, le impostazioni sono suddivise in diverse schede. Una caratteristica super utile è che un esempio dell'operazione è mostrato nella parte destra della finestra: Lo screenshot mostra che possiamo impostare "Chained method calls" su "wrap always", cioè dividere sempre le chiamate di metodo concatenate in righe separate. Ora fai di nuovo clic sul pulsante di formattazione nella classe di test e vediamo che funziona davvero! Ma a volte è necessario formattare del codice al di fuori delle regole di formattazione standard. Impostare la formattazione come segue: Per impedire la formattazione, nella sezione "Code Style", abilita i marcatori di formattazione: Ora possiamo cambiare la nostra classe di test in modo che il suo codice non venga riformattato:

 @Test
 public void testSumOfOddNumbers() {
 	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
 	// @formatter:off
 	Integer result = data.stream().filter(number -> number % 2 == 0)
                              .reduce((n1, n2) -> n1 + n2)
                              .get();
 	assertThat(result, is(12));
 	// @formatter:on
 }

Potresti aver notato che quando premi Tab, IDEA lo interpreta come uno spazio (questo è il comportamento predefinito). Ma puoi cambiarlo nella Code Stylesezione " ": Come puoi vedere, ci sono molte impostazioni lì. Puoi leggere maggiori dettagli sulle Code styleimpostazioni di " " qui: " IDEA Help: Code Style ". C'è un'altra importante caratteristica di formattazione: la formattazione delle importazioni. Questa operazione viene eseguita separatamente e si chiama " Optimize Imports". Si trova sotto Code -> Optimize Imports(Ctrl+Alt+O). L'ottimizzazione delle importazioni rimuove le importazioni non necessarie e dispone le importazioni nell'ordine corretto in base alle impostazioni nella Importsscheda " " delle Code Styleimpostazioni " " per Java. Inoltre, se desideri che questa formattazione avvenga automaticamente, ci sono buone notizie:Plug -in Salva azioni .

Distribuzione delle impostazioni in un comando

Abbiamo visto sopra che puoi personalizzare il tuo stile di formattazione come preferisci. Ma come si usa questo stile all'interno di un team? Molto facilmente. Ci sono diverse opzioni. Il più semplice è salvare uno schema di stile del codice. Apri le impostazioni IDEA usando File -> Settings(o premi Ctrl+Alt+S). Nella Code Stylesezione " ", possiamo vedere "Schema". Questo è il nostro schema di formattazione. Per impostazione predefinita, viene utilizzato lo schema "Predefinito" ed è etichettato come "IDE", il che significa che questa impostazione si applica solo al nostro IDE, non influisce su nessun altro. Per creare uno schema "personalizzato", utilizzare il pulsante a destra per fare una copia e assegnargli un nome, ad esempio: CodeGym Quindi possiamo importare o esportare le impostazioni: Un'altra opzione è importare le impostazioni IDEA: Una terza opzione è il repository delle impostazioni. Per utilizzare il repository delle impostazioni, consultare la documentazione della guida di IntelliJ IDEA per maggiori dettagli al seguente collegamento: repository delle impostazioni ". Parlando di spingere uno stile unificato in un team, non posso fare a meno di menzionare il buon supporto per gli stili da Eclipse IDE. Per fare ciò, è necessario installare un plug-in separato: apri le impostazioni IDEA tramite File -> Impostazioni (Ctrl+Alt+S) e vai alla sezione "Plugin". Per trovare nuovi plug-in, fai clic sul pulsante " ". Browse RepositoriesQuindi trova il plug-in Eclipse Code Formatter nella finestra di ricerca. Dopo averlo installato, dovrai riavviare IDEA — questa è la procedura standard. Ora tutto è fatto. C'è una nuova sezione nelle impostazioni IDEA: "Eclipse Code Formatter".. Sarà simile a questo:

Requisiti più severi

Oltre agli strumenti IDEA, puoi anche utilizzare i plug-in di automazione della compilazione per rafforzare i requisiti. Non è possibile verificare manualmente che qualcuno abbia utilizzato la formattazione corretta. Forse potresti farlo con 5 persone in una squadra. Ma con 100 persone in un'azienda, non è realistico. E anche cinque saranno difficili da rintracciare. E perché sprecare il tuo tempo in tutto questo? Sarebbe molto più facile impedire la realizzazione del progetto se le regole vengono violate. In effetti, questo è un argomento completamente separato chiamato "Ispeziona codice". In questo articolo, voglio solo mostrarti come funziona. Uno dei plugin Gradle più popolari (perché costruisce il nostro progetto, ricorderete) è pmd. Per abilitarlo, vai allo script di build del nostro progetto Gradle (il file build.gradle alla radice del nostro progetto) e aggiungi pmd accanto al resto dei plugin:

 plugins {
     // Apply the java plugin to add support for Java
     id 'java'
     // Check source code
     id 'pmd'
     // Apply the application plugin to add support for building an application
     id 'application'
 }

Ora possiamo inserire impostazioni più dettagliate nello stesso posto:

 pmd {
     ignoreFailures = false
     pmdTest.enabled = true
     ruleSets = [
             'java-basic',
             'java-braces',
             'java-clone',
             'java-codesize',
             'java-comments',
             'java-controversial',
             'java-coupling',
             'java-design',
             'java-empty',
             'java-finalizers',
             'java-imports',
             'java-optimizations',
             'java-strictexception',
             'java-strings',
             'java-typeresolution',
             'java-unnecessary',
             'java-unusedcode'
     ]
 }

Anche il nostro progetto adesso è fallito. Esegui gradle builde otteniamo un errore. La cosa bella è che durante la compilazione viene generato un rapporto. E se ci sono errori, riceviamo un messaggio come questo:

 BUILD FAILED in 35s
 6 actionable tasks: 6 executed
 7 PMD rule violations were found. See the report at: file:///C:/_study/codestyle/build/reports/pmd/main.html

Andando al rapporto, vediamo qualcosa del genere: Inoltre, la Problemcolonna " " fornisce un collegamento a una descrizione del problema sul sito Web del plug-in pmd. Ad esempio, per l'errore " headerCommentRequirement Required", il collegamento va qui: pmd — CommentRequired . Questo errore indica che la nostra classe non ha un JavaDoc. Possiamo utilizzare i modelli per configurare un JavaDoc sopra le classi: E specificare i contenuti per File Header: Successivamente, possiamo trasformare il commento sopra la classe App in un JavaDoc e vedere che l'errore è scomparso in una nuova build.

La linea di fondo

Lo stile del codice è importante per massimizzare la produttività di un progetto. Un bel codice scritto secondo regole condivise garantisce che i tuoi colleghi lo capiranno più facilmente e rapidamente e non ti daranno un orecchio di critica. Con i moderni strumenti di sviluppo, non è così difficile attenersi alle regole di stile. Spero che questa recensione ti abbia dimostrato che questo è vero. Seguendo la tradizione, ecco un po' di materiale extra sull'argomento:

• Video da JetBrainsTV: " Inspect Code (IntelliJ IDEA) "
• Recensione di " Analisi del codice con plugin Gradle "
• Corso " Automazione della qualità del codice ".