Coffee break #86. Isang Mabilis at Madaling Gabay sa Pag-reformat ng Code sa IntelliJ IDEA

Source: Lightrun Bilang isang developer, kailangan mong gumawa ng mga pagbabago sa codebase. At kung ang code base ay hindi malinaw na na-format, ang pag-debug ay magiging mas mahirap para sa iyo. Ang mga maliliit na pagbabago tulad ng reformatting at wastong indentation sa code ay kadalasang napapansin, ngunit malinaw na nakakatulong ang mga ito na maiba ang codebase ng isang propesyonal na developer mula sa codebase ng isang baguhan. Ang pagpapanatili ng wastong pag-format ng code at indentation ay makakatulong sa iyong magsulat ng code na mas madaling basahin. Pinapasimple nito ang pakikipagtulungan sa mga proyekto, pinatataas ang bilis ng pag-debug at pagpapanatili ng code base. Ang code ay nagiging mas nababasa at nakabalangkas. Posible bang pabilisin ang proseso ng pag-reformat ng code? Ipakikilala sa iyo ng artikulong ito ang isang simpleng paraan para sa awtomatikong pag-reformat ng code gamit ang IntelliJ IDEA. Matututuhan mo kung paano bawasan ang oras na kinakailangan para sa pamamaraang ito, at matututunan mo rin kung paano ibukod ang mga bahagi ng codebase mula sa muling pag-format gamit ang iba't ibang mga keyboard shortcut.

Mga benepisyo ng reformatting

Mahalagang tandaan na walang kinakailangang pag-format o code ng pagkomento para gumana ang function. Anumang code, mayroon man o walang pag-format, ay maaaring ganap na basahin at isakatuparan ng compiler. Sa kabilang banda, ginagawang mas madali ng reformatting ang markup para mabasa ng mga tao. Para sa compiler, ang mahalaga lang ay gumagana ang code at hindi ito naglalaman ng mga error, at hindi kung gaano ito kahusay o kung gaano kaganda ang pagkaka-indent nito. Totoo, ito ang huli na nag-aalala sa mga tao, dahil kailangan nilang basahin ang naturang code. Tulad ng plain text, walang gustong magbasa ng walang anyo na content nang walang mga heading, paragraph, o anumang indentation. Ang ilan sa mga kinakailangang reformatting techniques ay kinabibilangan ng:

• Indent.
• Mga function ng istilo at pagsulat.
• Walang laman na espasyo.
• Paggamit ng malalaking titik at pangalan.

Ang pag-debug ay isang kinakailangang kasamaan na madalas makaharap ng isang developer sa kabuuan ng kanilang karera. Saan magsisimula kung ang iyong codebase ay kalat at hindi organisado? Kapag maayos na na-format at naka-indent ang source code, lumilitaw na hindi gaanong naka-cluster. Ginagawa nitong mas madaling matukoy kung saan matatagpuan ang iba't ibang mga module ng application. Dahil dito, nagiging mas madali ang paghahanap ng mga problema at pagkakamali. Ang pag-reformat ng code sa IntelliJ IDEA ay batay sa mga kinakailangan na tinukoy sa mga setting ng istilo ng code sa IDE. Bagaman, kapag ginamit mo ang EditorConfig sa iyong proyekto, ang mga setting na iyong tinukoy sa .editorconfig file ay sa pamamagitan ng default ay i-override ang mga tinukoy sa mga setting ng estilo ng code. Ang pag-reformat sa IntelliJ ay hindi naiiba sa pagtatrabaho sa ibang mga IDE. May mga opsyon para sa muling pag-format ng parehong isang bloke ng code at ang buong file. Maaaring may mga pagkakataon na medyo mahaba ang iyong buong block ng code at gusto mong ma-reformat ang lahat maliban sa ilang partikular na lugar. Sa kasong ito, ang indibidwal na pagpili ng mga bahagi ng code na gusto mong i-format ay talagang hindi ang pinakamahusay na pagpipilian. Sa ganitong mga sitwasyon, tiyak na magiging kapaki-pakinabang ang pag-reformat gamit ang IntelliJ. I-explore natin ito at ang iba pang gamit ng IDE.

Mga tip para sa pag-format ng code

Tingnan natin ang ilang pangunahing tip para sa pag-format ng code sa pangkalahatan:

• Siguraduhin na ang iyong code ay maayos na nagkomento. Gumamit ng mga komento upang ipahiwatig ang layunin at kahulugan. Kahit na ikaw lang ang nagbabasa ng code na ito, kapaki-pakinabang pa rin na paalalahanan ang iyong sarili ng layunin ng ilang mga bloke ng code. Mapapadali nito ang mga bagay kung babalik ka sa iyong codebase pagkatapos ng bakasyon, halimbawa.

• Huwag gumamit ng mga tab para sa mga puwang sa parehong linya. Binabawasan nito ang pagiging madaling mabasa ng code.

• Magdagdag ng TODO sa iyong mga bloke ng code upang masubaybayan ang mga pagpapatupad sa hinaharap. Sa ganitong paraan, kapag na-reformat mo ang iyong code, hindi ito lilikha ng ilusyon na kumpleto na ang iyong trabaho.

• Huwag gumamit ng code reformatting bilang isang mabilis na pag-aayos para sa mga error sa syntax.

• Iwasan ang malalim na pamumuhunan. Ito ay isang karaniwang kasanayan sa ilang mga developer, ngunit ang malalim na nested code ay nagpapahirap sa pagbasa at nagpapakilala ng mga error na hindi madaling makita sa unang tingin.

Reformatting code sa IntelliJ IDEA

Bago namin tuklasin ang iba't ibang paraan upang i-format ang code sa IntelliJ, magsimula sa paggawa ng sample na proyekto ng Java sa iyong IDE. Sa sandaling ilunsad mo ang IntelliJ, dapat mong makita ang isang screen na tulad nito: I-click ang Susunod at kumpletuhin ang pag-setup ng pagsisimula ng proyekto. Ngayong naka-set up na ang iyong proyekto, oras na para magdagdag ng sample code para matulungan kang maunawaan ang pag-reformat ng code sa IntelliJ. Ito ay isang simpleng word counter mula sa University of Texas:

import java.io.File;
import java.io.IOException;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class SimpleWordCounter {

    public static void main(String[] args) {
        try {
            File f = new File("ciaFactBook2008.txt");
            Scanner sc;
            sc = new Scanner(f);
            // sc.useDelimiter("[^a-zA-Z']+");
            Map<String, Integer> wordCount = new TreeMap<String, Integer>();
            while(sc.hasNext()) {
                String word = sc.next();
                if(!wordCount.containsKey(word))
                    wordCount.put(word, 1);
                else
                    wordCount.put(word, wordCount.get(word) + 1);
            }

            // show results
            for(String word : wordCount.keySet())
                System.out.println(word + " " + wordCount.get(word));
            System.out.println(wordCount.size());
        }
        catch(IOException e) {
            System.out.println("Unable to read from file.");
        }
    }
}

Pag-reformat ng mga snippet ng code

Magsimula tayo sa pamamagitan ng pag-format ng mga snippet ng code. Upang gawin ito, i-highlight lang ang bahagi ng code na gusto mong i-format at i-click ang Code > Reformat Code . Tulad ng nakikita mo, ang naka-highlight na bahagi ng iyong code (sa kasong ito, mga linya 11-17) ay na-format nang tama. Tingnan natin ang "bago" at "pagkatapos" ng muling pag-format ng aming snippet ng code. Kung napansin mo sa unang larawan, ang deklarasyon at pagsisimula ng iyong variable ay nangyari sa parehong linya tulad ng try . Ang pagsasara ng mga kulot na braces ay pinaghalo sa ibang bloke . Ngunit pagkatapos i-highlight ang bahaging ito ng iyong code at gamitin ang opsyon sa pag-reformat, magkakaroon ka ng isang bloke ng code na mas kasiya-siya sa mata. Ang kumpletong code para sa iyong klase ay mukhang ganito na ngayon: Pansinin na tanging ang code block na iyong pinili ang na-reformat.

Pag-reformat ng buong file

Upang i-reformat ang buong file, buksan ang editor, ilagay ang cursor kahit saan at i-click ang Code >Reformat File . Ipo-prompt kang piliin ang naaangkop na mga opsyon sa pag-reformat para sa buong file. Ire-reformat ng pagkilos na ito ang lahat ng iyong code sa aktibong editor. Ang iyong code ay magiging katulad nito:

Pag-reformat ng isang module o direktoryo

Upang gawin ito, ang kailangan mo lang gawin ay i-right-click ang module sa window ng mga tool ng proyekto at piliin ang Reformat Code . Sa pop-up window, piliin ang alinman sa tatlong opsyon na kailangan mo:

• I-optimize ang Mga Pag-import : Piliin ang opsyong ito kung gusto mong magdagdag ng mga nawawalang pahayag ng pag-import at alisin din ang mga hindi nagamit na pag-import.

• Muling Ayusin ang Mga Entri : Upang muling ayusin ang code ayon sa mga panuntunan sa layout na tinukoy sa mga setting ng estilo ng code.

• Cleanup code : upang patakbuhin ang code cleanup.

Kapag tapos ka na, i-click lang ang OK.

Hindi kasama ang code sa muling pag-format

Tingnan natin kung ano ang gagawin kung mayroon kang isang bloke ng code na hindi mo gustong isama kapag pino-format ang buong file. Pumunta sa File > Settings o gamitin ang keyboard shortcut na Ctrl + Alt + S. Pumunta sa Editor > Code Style at lagyan ng check ang Enable formatter marker sa menu ng mga komento sa Formatter Control na tab . Sa iyong editor, lumikha ng komento sa linya at i-type ang //@formatter:off nang walang mga panipi sa simula ng lugar na gusto mong ibukod. Sa dulo ng lugar, lumikha ng isa pang komento sa linya at ilagay ang //@formatter:on , nang walang mga panipi. Sa larawan sa itaas, makikita mo na babalewalain ng formatter ang iyong code sa linya 23 dahil lang sa tinukoy mo ito sa mga komento at format controller.

Mga halimbawa ng mga hotkey para sa muling pag-format

• I-reformat ang block ng code: Ctrl + Alt + Shift + L
• I-reformat ang file: Ctrl + Alt + L
• Magdagdag ng komento sa linya: Ctrl + /
• Magdagdag ng block comment: Ctrl + Shift + /

Konklusyon

Ang pagbibigay-pansin sa mga format ng code ay kasinghalaga para sa isang developer bilang paggawa nito. Hindi mo masasabi kung sino ang magtatrabaho sa iyong code. Ang pagkakaroon ng madaling basahin at maayos na code base ay tumutukoy sa isang propesyonal na developer. Sa IntelliJ IDEA, ang pag-format ng iyong code ay hindi kailangang maging kasing hirap ng pagsulat ng code mismo. Sa susunod na magsulat ka ng code gamit ang IntelliJ, gamitin ang mga tip na ito. Gagawin nitong mas madali ang iyong buhay kapag nagde-debug ng iyong code.