IntelliJ IDEA: Estilo ng coding at pag-format ng code

Ang isang programming language ay halos kapareho sa isang pasalitang wika. Ang pinagkaiba lang ay ito ay isang espesyal na wika na ang pangunahing layunin ay upang mapadali ang komunikasyon sa isang computer upang maipaliwanag sa computer kung ano ang gusto nating gawin nito. Ngunit hindi ka maaaring magkaroon ng personal na pakikipag-usap sa isang computer. Noong nagsimula kang mag-aral ng programming language, tumingin ka sa mga libro o ilang mapagkukunang pang-edukasyon tulad ng CodeGym. At ipinakita sa iyo ng mapagkukunang ito ang code na naiintindihan ng computer. Ngunit dapat mo ring maunawaan ito habang natututo ka tungkol sa wikang Java. Tulad ng anumang wika, ang ilang mga kumbensyon sa pag-format ay pinagtibay sa programming. Halimbawa, sa magalang na lipunan, maituturing na masama ang pag-uugali . At sa Java, ang pagsisimula ng pangalan ng pamamaraan na may malaking titik ay isang matinding paglabag sa mga coding convention. Ang mga patakaran para sa Java code ay ibinibigay sa dokumentong Code Conventions para sa Java Programming Language . Ang mga coding convention ay maaari ding mag-regulate ng mas maliliit na detalye, gaya ng indentation. Isipin ang lubos na bangungot na magiging bersyon ng control kung hindi pare-pareho ang indentation, ang ilang tao ay gumagamit ng mga tab at ibang tao ang gumagamit ng mga puwang. Ano kaya ang mangyayari para sa isang taong kailangang mag-check in ng isang pag-aayos sa isang paraan lang, ngunit nakitang nagbago ang buong file dahil sa mga pagkakaiba sa mga espasyo at tab? Siyempre, gaya ng ordinaryong wika, maaaring magbago ang mga kombensiyon depende sa kung saan ginagamit ang isang wika. Halimbawa, sa malawak na kalawakan ng web, mahahanap mo ang Google Java Style Guide at ang Twitter Java Style Guide. Para sa pagsusuring ito, kailangan namin ng paksa ng pagsusulit. Gagamitin namin ang Gradle build automation system. Ito ay magbibigay-daan sa amin na makapagsimula nang mabilis sa pamamagitan ng paglikha ng isang bagong proyekto mula sa isang template. May magandang plugin ang Gradle: Build Init Plugin . Pumunta tayo sa isang bagong direktoryo at patakbuhin ang sumusunod na command doon: gradle init --type java-application Pagkatapos nito, simulan ang IntelliJ IDEA. Kung makakita ka ng window na may bukas na proyekto (ibig sabihin, nakikita mo ang code editor at project tree), isara ang proyektong ito gamit ang File -> Close Project. Ngayon sa welcome window, patakbuhin ang " Import Project" at i-import ang aming bagong proyekto. Kapag nag-import, itakda ang Use autoimportcheckbox na " ". Alamin natin kung magagamit ba natin ang makabagong mga tool sa pag-unlad upang kahit papaano ay pasimplehin ang buhay.

Pag-format ng code sa IDEA

Pagkatapos i-import ang proyekto, pindutin ang Ctrl+N at pumunta sa AppTestklase. Ito ang default na klase ng pagsubok. Mukhang ganito:

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());
    }
}

Ano agad ang pumukaw sa iyong mata? Isang anotasyon sa parehong linya bilang isang deklarasyon ng pamamaraan, na mukhang pangit, tama? Paano ito ayusin? Ang IntelliJ IDEA ay may " Code" menu entry para sa iba't ibang manipulasyon ng code. Ang isa sa gayong pagmamanipula ay " Reformat Code", na maaari mong ilapat gamit ang Ctrl+L. Pagkatapos mong gawin ito, ang anotasyon ay nasa isang linya, at ang paraan ng deklarasyon sa isa pa. Mahalagang tandaan kaagad na ang operasyong ito ay ginagawa sa kasalukuyang napiling code . Kung walang pagpili, kung gayon ang operasyon ng pag-format ay isinasagawa sa lahat. Ngayon magdagdag tayo ng bagong paraan ng pagsubok:

@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));
}

At dalawang import:

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

Tulad ng nakikita mo, ang operasyon sa Stream ay nasa isang linya. Ngunit paano kung gusto nating tiyakin na ang mga tawag na nakakadena sa pamamaraan ay palaging nahahati sa mga bagong linya sa bawat operator ng panahon? Maaari naming gawin ito nang manu-mano. Ngunit tandaan na gusto nating awtomatikong mangyari ang lahat. Sa katunayan, tiyak na malilimutan namin ang manu-manong hakbang paminsan-minsan, at pagkatapos ay mapupunta kami sa iba't ibang pag-format sa lahat ng dako, at hindi iyon mabuti. Kaya kailangan nating i-edit ang panuntunang ginagamit ng IDEA para sa pag-format. PumiliFile -> Settingssa menu ng IDEA (o pindutin ang Ctrl+Alt+S). Ipasok ang "Estilo ng code" sa field ng paghahanap sa window ng mga setting. Sa seksyong "Estilo ng code," maaari mong tukuyin ang mga setting para sa higit pang mga wika kaysa sa Java lamang. Ngunit ang Java ang kinaiinteresan namin ngayon. Tulad ng nakikita mo, ang mga setting ay nahahati sa ilang mga tab. Ang isang napaka-kapaki-pakinabang na tampok ay ang isang halimbawa ng operasyon ay ipinapakita sa kanang bahagi ng window: Ang screenshot ay nagpapakita na maaari naming itakda ang "Chained method calls" sa "wrap always", ibig sabihin, palaging hatiin ang chained method calls sa magkahiwalay na linya. Ngayon i-click muli ang pindutan ng pag-format sa klase ng pagsubok at nakita namin na talagang gumagana ito! Ngunit minsan kailangan mong mag-format ng ilang code sa labas ng karaniwang mga panuntunan sa pag-format. I-set up ang pag-format tulad ng sumusunod: Upang maiwasan ang pag-format, sa seksyong "Estilo ng Code," paganahin ang mga tagamarka ng formatter: Ngayon ay maaari na nating baguhin ang aming klase ng pagsubok upang hindi ma-reformat ang code nito:

@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
}

Maaaring napansin mo na kapag pinindot mo ang Tab, binibigyang-kahulugan ito ng IDEA bilang isang espasyo (ito ang default na gawi). Ngunit maaari mong baguhin ito sa Code Styleseksyong " ": Gaya ng nakikita mo, maraming mga setting doon. Maaari kang magbasa ng higit pang mga detalye tungkol sa " Code style" mga setting dito: " IDEA Help: Code Style ". May isa pang mahalagang tampok sa pag-format: pag-format ng mga pag-import. Ang operasyong ito ay hiwalay na pinapatakbo at tinatawag na " Optimize Imports". Ito ay matatagpuan sa ilalim ng Code -> Optimize Imports(Ctrl+Alt+O). Ang pag-optimize ng mga pag-import ay nag-aalis ng mga hindi kinakailangang pag-import at nag-aayos ng mga pag-import sa tamang pagkakasunud-sunod ayon sa mga setting sa Importstab na " " ng " Code Style" na mga setting para sa Java. Higit pa, kung gusto mong awtomatikong mangyari ang pag-format na ito, may magandang balita:Plugin ng Save Actions .

Pamamahagi ng mga setting sa isang command

Nakita namin sa itaas na maaari mong i-customize ang iyong istilo ng pag-format sa kahit anong gusto mo. Ngunit paano mo ginagamit ang istilong ito sa loob ng isang koponan? Napakadali. Mayroong ilang mga pagpipilian. Ang pinakasimpleng ay ang pag-save ng isang code style scheme. Buksan ang mga setting ng IDEA gamit ang File -> Settings(o pindutin ang Ctrl+Alt+S). Sa Code Styleseksyong " ", makikita natin ang "Skema". Ito ang aming formatting scheme. Bilang default, ginagamit ang "Default" na scheme at may label na "IDE", na nangangahulugang ang setting na ito ay nalalapat lamang sa aming IDE — hindi ito nakakaapekto sa sinuman. Upang gumawa ng "custom" na scheme, gamitin ang button sa kanan para gumawa ng kopya at bigyan ito ng pangalan, halimbawa: CodeGym Pagkatapos ay maaari nating i-import o i-export ang mga setting: Ang isa pang opsyon ay ang pag-import ng mga setting ng IDEA: Ang ikatlong opsyon ay ang Settings Repository. Para gamitin ang Settings Repository, tingnan ang IntelliJ IDEA Help documentation para sa higit pang mga detalye sa sumusunod na link: Settings Repository ". Sa pagsasalita tungkol sa pagtulak ng pinag-isang istilo sa isang team, hindi ko rin maiwasang banggitin ang magandang suporta para sa mga istilo mula sa Eclipse IDE. Upang gawin ito, kailangan mong mag-install ng hiwalay na plugin: buksan ang mga setting ng IDEA sa pamamagitan ng File -> Settings (Ctrl+Alt+S) at pumunta sa seksyong "Mga Plugin." Upang makahanap ng mga bagong plugin, i-click ang " " button. Browse RepositoriesPagkatapos hanapin ang plugin ng Eclipse Code Formatter sa window ng paghahanap. Pagkatapos i-install ito, kailangan mong i-restart ang IDEA — ito ay karaniwang pamamaraan. Tapos na ang lahat. May bagong seksyon sa mga setting ng IDEA: "Eclipse Code Formatter".. Magiging ganito ang hitsura nito:

Mas mahigpit na mga kinakailangan

Bilang karagdagan sa mga tool ng IDEA, maaari ka ring gumamit ng mga build automation plugin upang higpitan ang mga kinakailangan. Walang paraan na maaari mong manu-manong suriin kung may gumamit ng wastong pag-format. Siguro maaari mong kasama ang 5 tao sa isang koponan. Ngunit sa isang 100 tao sa isang kumpanya, hindi ito makatotohanan. At kahit lima ay mahirap subaybayan. At bakit mag-aaksaya ng iyong oras sa alinman sa mga ito? Mas madaling pigilan ang pagtatayo ng proyekto kung nilalabag ang mga patakaran. Sa katunayan, ito ay isang buong hiwalay na paksa na tinatawag na "Inspect Code". Sa artikulong ito, gusto ko lang ipakita sa iyo kung paano ito gumagana. Ang isa sa mga pinakasikat na plugin ng Gradle (dahil binubuo nito ang aming proyekto, maaalala mo) ay pmd. Upang paganahin ito, pumunta lamang sa build script ng aming proyekto sa Gradle (ang build.gradle file sa ugat ng aming proyekto) at magdagdag ng pmd dito sa tabi ng iba pang mga 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'
}

Ngayon ay maaari na tayong magpasok ng mas detalyadong mga setting sa parehong lugar:

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'
    ]
}

Pati ang project natin ay sira na ngayon. Tumakbo gradle buildat magkakaroon tayo ng error. Ang maganda ay ang isang ulat ay nabuo sa panahon ng pagbuo. At kung may mga error, nakakakuha kami ng mensahe tulad nito:

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

Pagpunta sa ulat, may makikita kaming ganito: Bukod dito, ang Problemcolumn na " " ay nagbibigay ng link sa isang paglalarawan ng problema sa website ng pmd plugin. Halimbawa, para sa " headerCommentRequirement Required" error, napupunta ang link dito: pmd — CommentRequired . Ang error na ito ay isang pahiwatig na ang aming klase ay walang JavaDoc. Maaari kaming gumamit ng mga template upang i-configure ang isang JavaDoc sa itaas ng mga klase: At tukuyin ang mga nilalaman para sa File Header: Pagkatapos nito, maaari naming gawing JavaDoc ang komento sa itaas ng klase ng App at makita na ang error ay nawala sa isang bagong build.

Ang ilalim na linya

Ang istilo ng code ay mahalaga upang mapakinabangan ang pagiging produktibo sa isang proyekto. Ang magandang code na nakasulat ayon sa nakabahaging mga panuntunan ay ginagarantiyahan na ang iyong mga katrabaho ay mas madali at mabilis na mauunawaan ito at hindi ka bibigyan ng anumang pamumuna. Gamit ang mga modernong tool sa pag-unlad, hindi napakahirap na manatili sa mga panuntunan sa istilo. Sana ay napatunayan sa iyo ng pagsusuring ito na totoo ito. Kasunod ng tradisyon, narito ang kaunting karagdagang materyal sa paksa:

• Video mula sa JetBrainsTV: " Inspect Code (IntelliJ IDEA) "
• Pagsusuri ng " Pagsusuri ng Code Gamit ang Gradle Plugin "
• " I-automate ang Kalidad ng Code " na kurso