IntelliJ IDEA: కోడింగ్ శైలి మరియు కోడ్ ఫార్మాటింగ్

ప్రోగ్రామింగ్ లాంగ్వేజ్ మాట్లాడే భాషకు చాలా పోలి ఉంటుంది. ఒకే తేడా ఏమిటంటే, ఇది ఒక ప్రత్యేక భాష, దీని ముఖ్య ఉద్దేశ్యం కంప్యూటర్‌తో కమ్యూనికేషన్‌ను సులభతరం చేయడం ద్వారా మనం ఏమి చేయాలనుకుంటున్నామో దానిని కంప్యూటర్‌కు వివరించడం. కానీ మీరు కంప్యూటర్‌తో వ్యక్తిగత సంభాషణ చేయలేరు. మీరు ప్రోగ్రామింగ్ లాంగ్వేజ్ నేర్చుకోవడం ప్రారంభించినప్పుడు, మీరు పుస్తకాలు లేదా కోడ్‌జిమ్ వంటి కొన్ని విద్యా వనరులను చూశారు. మరియు ఈ వనరు కంప్యూటర్ అర్థం చేసుకునే కోడ్‌ని మీకు చూపింది. కానీ మీరు జావా భాష గురించి తెలుసుకున్నప్పుడు మీరు కూడా అర్థం చేసుకోవాలి. ఏదైనా భాషలో వలె, ప్రోగ్రామింగ్‌లో కొన్ని ఫార్మాటింగ్ సంప్రదాయాలు స్వీకరించబడ్డాయి. ఉదాహరణకు, మర్యాదపూర్వక సమాజంలో, wRiTiNg ఇలాంటివి చెడు మర్యాదలుగా పరిగణించబడతాయి. మరియు జావాలో, ఒక పద్ధతి పేరును పెద్ద అక్షరంతో ప్రారంభించడం అనేది కోడింగ్ సంప్రదాయాల యొక్క స్థూల ఉల్లంఘన. జావా ప్రోగ్రామింగ్ లాంగ్వేజ్ కోసం డాక్యుమెంట్ కోడ్ కన్వెన్షన్స్‌లో జావా కోడ్ కోసం నియమాలు ఇవ్వబడ్డాయి . కోడింగ్ కన్వెన్షన్‌లు ఇండెంటేషన్ వంటి చిన్న వివరాలను కూడా నియంత్రించగలవు. ఇండెంటేషన్ అస్థిరంగా ఉంటే, కొంత మంది వ్యక్తులు ట్యాబ్‌లను ఉపయోగిస్తున్నారు మరియు మరికొందరు ఖాళీలను ఉపయోగిస్తున్నట్లయితే, సంస్కరణ నియంత్రణ అనేది పూర్తిగా పీడకలగా మారుతుందని ఊహించండి. కేవలం ఒక పద్ధతిలో ఫిక్స్‌లో చెక్ చేయాల్సిన అవసరం ఉన్న వ్యక్తికి అది ఎలా ఉంటుంది, అయితే స్పేస్‌లు మరియు ట్యాబ్‌లలో తేడాల కారణంగా మొత్తం ఫైల్ మారిపోయింది? సహజంగానే, సాధారణ భాషలో లాగా, ఒక భాష ఎక్కడ ఉపయోగించబడుతుందనే దానిపై ఆధారపడి సంప్రదాయాలు మారవచ్చు. ఉదాహరణకు, విస్తృతమైన వెబ్‌లో, మీరు Google జావా స్టైల్ గైడ్ మరియు Twitter జావా స్టైల్ గైడ్‌లను కనుగొనవచ్చు. ఈ సమీక్ష కోసం, మాకు పరీక్ష విషయం అవసరం. మేము Gradle బిల్డ్ ఆటోమేషన్ సిస్టమ్‌ని ఉపయోగిస్తాము. ఇది టెంప్లేట్ నుండి కొత్త ప్రాజెక్ట్‌ను సృష్టించడం ద్వారా త్వరగా ప్రారంభించడానికి అనుమతిస్తుంది. Gradle ఒక గొప్ప ప్లగ్ఇన్‌ను కలిగి ఉంది: Init ప్లగిన్‌ని రూపొందించండి . కొత్త డైరెక్టరీకి వెళ్లి, కింది ఆదేశాన్ని అమలు చేద్దాం: gradle init --type java-application ఆ తర్వాత, IntelliJ IDEAని ప్రారంభించండి. మీరు ఓపెన్ ప్రాజెక్ట్‌తో విండోను చూసినట్లయితే (అంటే మీరు కోడ్ ఎడిటర్ మరియు ప్రాజెక్ట్ ట్రీని చూస్తారు), ఉపయోగించి ఈ ప్రాజెక్ట్‌ను మూసివేయండి File -> Close Project. ఇప్పుడు స్వాగత విండోలో, " Import Project"ని అమలు చేసి, మా కొత్త ప్రాజెక్ట్‌ను దిగుమతి చేయండి. దిగుమతి చేస్తున్నప్పుడు, " Use autoimport" చెక్‌బాక్స్‌ని సెట్ చేయండి. జీవితాన్ని సులభతరం చేయడానికి అత్యాధునిక అభివృద్ధి సాధనాలను ఉపయోగించవచ్చో లేదో తెలుసుకుందాం.

IDEAలో కోడ్ ఫార్మాటింగ్

ప్రాజెక్ట్‌ను దిగుమతి చేసిన తర్వాత, Ctrl+N నొక్కి, తరగతికి వెళ్లండి AppTest. ఇది డిఫాల్ట్ పరీక్ష తరగతి. ఇది ఇలా కనిపిస్తుంది:

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

వెంటనే మీ దృష్టిని ఆకర్షించేది ఏమిటి? మెథడ్ డిక్లరేషన్ వలె అదే లైన్‌లో ఉల్లేఖనం, ఇది అసహ్యంగా కనిపిస్తుంది, సరియైనదా? దీన్ని ఎలా పరిష్కరించాలి? IntelliJ IDEA Codeవివిధ కోడ్ మానిప్యులేషన్‌ల కోసం మెను ఎంట్రీని కలిగి ఉంది. అటువంటి తారుమారు " Reformat Code", మీరు Ctrl+L ఉపయోగించి దరఖాస్తు చేసుకోవచ్చు. మీరు దీన్ని చేసిన తర్వాత, ఉల్లేఖనం ఒక లైన్‌లో మరియు పద్ధతి ప్రకటన మరొక లైన్‌లో ఉంటుంది. ఈ ఆపరేషన్ ప్రస్తుతం ఎంచుకున్న కోడ్‌లో నిర్వహించబడుతుందని వెంటనే గమనించాలి . ఎంపిక లేనట్లయితే, ప్రతిదానిపై ఫార్మాటింగ్ ఆపరేషన్ నిర్వహించబడుతుంది. ఇప్పుడు కొత్త పరీక్షా పద్ధతిని జోడిద్దాం:

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

మరియు రెండు దిగుమతులు:

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

మీరు చూడగలిగినట్లుగా, స్ట్రీమ్‌లో ఆపరేషన్ ఒక లైన్‌లో ఉంది. కానీ ప్రతి పీరియడ్ ఆపరేటర్ వద్ద చైన్డ్ మెథడ్ కాల్‌లు ఎల్లప్పుడూ కొత్త లైన్‌లుగా విభజించబడిందని మేము నిర్ధారించుకోవాలనుకుంటే? మేము దీన్ని మానవీయంగా చేయగలము. అయితే అన్నీ స్వయంచాలకంగా జరగాలని మనం కోరుకుంటున్నామని గుర్తుంచుకోండి. నిజమే, మేము ఎప్పటికప్పుడు మాన్యువల్ దశను ఖచ్చితంగా మరచిపోతాము, ఆపై మేము ప్రతిచోటా వేర్వేరు ఫార్మాటింగ్‌లతో ముగుస్తాము మరియు అది మంచిది కాదు. కాబట్టి ఫార్మాటింగ్ కోసం IDEA ఉపయోగించే నియమాన్ని మనం సవరించాలి. ఎంచుకోండిFile -> SettingsIDEA మెనులో (లేదా Ctrl+Alt+S నొక్కండి). సెట్టింగుల విండోలో శోధన ఫీల్డ్‌లో "కోడ్ శైలి"ని నమోదు చేయండి. "కోడ్ స్టైల్" విభాగంలో, మీరు జావా కంటే ఎక్కువ భాషల కోసం సెట్టింగ్‌లను పేర్కొనవచ్చు. అయితే ప్రస్తుతం మనకు ఆసక్తిగా ఉన్నది జావా. మీరు గమనిస్తే, సెట్టింగులు అనేక ట్యాబ్లుగా విభజించబడ్డాయి. ఒక సూపర్ ఉపయోగకరమైన ఫీచర్ ఏమిటంటే, విండో యొక్క కుడి భాగంలో ఆపరేషన్ యొక్క ఉదాహరణ చూపబడింది: స్క్రీన్‌షాట్ మనం "చైన్డ్ మెథడ్ కాల్‌లను" "ఎప్పుడూ చుట్టడానికి" సెట్ చేయగలమని చూపిస్తుంది, అనగా ఎల్లప్పుడూ చైన్డ్ పద్ధతి కాల్‌లను ప్రత్యేక పంక్తులుగా విభజించండి. ఇప్పుడు టెస్ట్ క్లాస్‌లో మళ్లీ ఫార్మాటింగ్ బటన్‌ను క్లిక్ చేయండి మరియు ఇది నిజంగా పనిచేస్తుందని మేము చూస్తాము! కానీ కొన్నిసార్లు మీరు ప్రామాణిక ఫార్మాటింగ్ నియమాల వెలుపల కొన్ని కోడ్‌లను ఫార్మాట్ చేయాలి. ఫార్మాటింగ్‌ను ఈ క్రింది విధంగా సెటప్ చేయండి: ఫార్మాటింగ్‌ను నిరోధించడానికి, "కోడ్ స్టైల్" విభాగంలో, ఫార్మాటర్ మార్కర్‌లను ప్రారంభించండి: ఇప్పుడు మనం మా పరీక్ష తరగతిని మార్చవచ్చు, తద్వారా దాని కోడ్ రీఫార్మాట్ చేయబడదు:

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

మీరు Tabని నొక్కినప్పుడు, IDEA దానిని స్పేస్‌గా అన్వయించడాన్ని మీరు గమనించి ఉండవచ్చు (ఇది డిఫాల్ట్ ప్రవర్తన). కానీ మీరు దీన్ని " " విభాగంలో మార్చవచ్చు Code Style: మీరు చూడగలిగినట్లుగా, అక్కడ చాలా సెట్టింగ్‌లు ఉన్నాయి. మీరు " " సెట్టింగ్‌ల గురించి మరిన్ని వివరాలను ఇక్కడ చదవవచ్చు Code style: " IDEA సహాయం: కోడ్ శైలి ". మరొక ముఖ్యమైన ఫార్మాటింగ్ ఫీచర్ ఉంది: ఫార్మాటింగ్ దిగుమతులు. ఈ ఆపరేషన్ విడిగా అమలు చేయబడుతుంది మరియు దీనిని "" అంటారు Optimize Imports. Code -> Optimize Importsఇది (Ctrl+Alt+O) కింద ఉంది . దిగుమతులను ఆప్టిమైజ్ చేయడం వలన అనవసరమైన దిగుమతులు తీసివేయబడతాయి మరియు జావా కోసం సెట్టింగ్‌ల "" Importsట్యాబ్‌లోని సెట్టింగ్‌ల ప్రకారం సరైన క్రమంలో దిగుమతులను ఏర్పాటు చేస్తుంది . Code Styleఅంతేకాదు, ఈ ఫార్మాటింగ్ స్వయంచాలకంగా జరగాలని మీరు కోరుకుంటే, శుభవార్త ఉంది:చర్యల ప్లగిన్‌ను సేవ్ చేయండి.

ఆదేశంలో సెట్టింగులను పంపిణీ చేస్తోంది

మీరు మీ ఫార్మాటింగ్ శైలిని మీకు నచ్చిన విధంగా అనుకూలీకరించవచ్చని మేము పైన చూశాము. కానీ మీరు జట్టులో ఈ శైలిని ఎలా ఉపయోగిస్తారు? చాలా సులభంగా. అనేక ఎంపికలు ఉన్నాయి. కోడ్ స్టైల్ స్కీమ్‌ను సేవ్ చేయడం చాలా సరళమైనది. ఉపయోగించి IDEA సెట్టింగ్‌లను తెరవండి File -> Settings(లేదా Ctrl+Alt+S నొక్కండి). " Code Style" విభాగంలో, మనం "స్కీమ్" చూడవచ్చు. ఇది మా ఫార్మాటింగ్ పథకం. డిఫాల్ట్‌గా, "డిఫాల్ట్" స్కీమ్ ఉపయోగించబడుతుంది మరియు "IDE" అని లేబుల్ చేయబడింది, అంటే ఈ సెట్టింగ్ మా IDEకి మాత్రమే వర్తిస్తుంది — ఇది ఎవరినీ ప్రభావితం చేయదు. "అనుకూల" స్కీమ్‌ను రూపొందించడానికి, కాపీని రూపొందించడానికి మరియు దానికి పేరు పెట్టడానికి కుడి వైపున ఉన్న బటన్‌ను ఉపయోగించండి, ఉదాహరణకు: CodeGym అప్పుడు మేము సెట్టింగ్‌లను దిగుమతి చేసుకోవచ్చు లేదా ఎగుమతి చేయవచ్చు: IDEA సెట్టింగ్‌లను దిగుమతి చేయడం మరొక ఎంపిక: మూడవ ఎంపిక సెట్టింగుల రిపోజిటరీ. సెట్టింగ్‌ల రిపోజిటరీని ఉపయోగించడానికి, ఈ క్రింది లింక్‌లో మరిన్ని వివరాల కోసం IntelliJ IDEA సహాయ డాక్యుమెంటేషన్‌ని చూడండి: సెట్టింగ్‌ల రిపోజిటరీ ". జట్టులో ఏకీకృత శైలిని పెంచడం గురించి మాట్లాడుతూ, నేను కూడా ఎక్లిప్స్ నుండి స్టైల్స్‌కు మంచి మద్దతును పేర్కొనకుండా ఉండలేను. IDE. దీన్ని చేయడానికి, మీరు ప్రత్యేక ప్లగిన్‌ను ఇన్‌స్టాల్ చేయాలి: ఫైల్ -> సెట్టింగ్‌లు (Ctrl+Alt+S) ద్వారా IDEA సెట్టింగ్‌లను తెరిచి, "ప్లగిన్‌లు" విభాగానికి వెళ్లండి. కొత్త ప్లగిన్‌లను కనుగొనడానికి, " " బటన్‌ని క్లిక్ చేయండి. Browse Repositoriesఆపై శోధన విండోలో ఎక్లిప్స్ కోడ్ ఫార్మాటర్ ప్లగ్ఇన్‌ను కనుగొనండి. దీన్ని ఇన్‌స్టాల్ చేసిన తర్వాత, మీరు IDEAని పునఃప్రారంభించవలసి ఉంటుంది — ఇది ప్రామాణిక ప్రక్రియ. ఇప్పుడు అంతా పూర్తయింది. IDEA సెట్టింగ్‌లలో కొత్త విభాగం ఉంది: "ఎక్లిప్స్ కోడ్ ఫార్మాటర్".. ఇది ఇలా కనిపిస్తుంది:

కఠినమైన అవసరాలు

IDEA సాధనాలతో పాటు, మీరు అవసరాలను బిగించడానికి బిల్డ్ ఆటోమేషన్ ప్లగిన్‌లను కూడా ఉపయోగించవచ్చు. ఎవరైనా సరైన ఫార్మాటింగ్‌ని ఉపయోగించారని మీరు మాన్యువల్‌గా తనిఖీ చేసే అవకాశం లేదు. మీరు బృందంలో 5 మంది వ్యక్తులతో ఉండవచ్చు. కానీ ఒక కంపెనీలో 100 మంది వ్యక్తులతో, ఇది వాస్తవమైనది కాదు. మరియు ఐదు కూడా ట్రాక్ చేయడం కష్టం. మరి వీటన్నింటిలో మీ సమయాన్ని ఎందుకు వృధా చేసుకుంటారు? నిబంధనలను ఉల్లంఘిస్తే ప్రాజెక్టును నిర్మించకుండా అడ్డుకోవడం చాలా సులభం అవుతుంది. వాస్తవానికి, ఇది "కోడ్‌ని తనిఖీ చేయి" అని పిలువబడే మొత్తం ప్రత్యేక అంశం. ఈ వ్యాసంలో, ఇది ఎలా పని చేస్తుందో నేను మీకు చూపించాలనుకుంటున్నాను. అత్యంత జనాదరణ పొందిన గ్రేడిల్ ప్లగిన్‌లలో ఒకటి (ఇది మా ప్రాజెక్ట్‌ను నిర్మిస్తుంది కాబట్టి, మీరు గుర్తుంచుకుంటారు) pmd. దీన్ని ఎనేబుల్ చేయడానికి, మా Gradle ప్రాజెక్ట్ యొక్క బిల్డ్ స్క్రిప్ట్‌కి (మా ప్రాజెక్ట్ యొక్క రూట్‌లోని build.gradle ఫైల్) వెళ్లి, మిగిలిన ప్లగిన్‌ల పక్కన దానికి pmdని జోడించండి:

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

ఇప్పుడు మనం అదే స్థలంలో మరింత వివరణాత్మక సెట్టింగ్‌లను నమోదు చేయవచ్చు:

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

మా ప్రాజెక్ట్ కూడా ఇప్పుడు విచ్ఛిన్నమైంది. రన్ చేయండి gradle buildమరియు మనకు లోపం వస్తుంది. మంచి విషయం ఏమిటంటే, నిర్మాణ సమయంలో నివేదిక రూపొందించబడింది. మరియు లోపాలు ఉంటే, మేము ఇలాంటి సందేశాన్ని అందుకుంటాము:

 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

నివేదికకు వెళితే, మేము ఇలాంటివి చూస్తాము: అంతేకాకుండా, " Problem" కాలమ్ pmd ప్లగిన్ వెబ్‌సైట్‌లో సమస్య యొక్క వివరణకు లింక్‌ను అందిస్తుంది. ఉదాహరణకు, " headerCommentRequirement Required" లోపం కోసం, లింక్ ఇక్కడకు వెళుతుంది: pmd — CommentRequired . ఈ లోపం మా తరగతికి JavaDoc లేదని సూచన. పైన ఉన్న తరగతులకు JavaDocని కాన్ఫిగర్ చేయడానికి మేము టెంప్లేట్‌లను ఉపయోగించవచ్చు: మరియు దీని కోసం కంటెంట్‌లను పేర్కొనండి File Header: ఆ తర్వాత, మేము యాప్ క్లాస్ పైన ఉన్న వ్యాఖ్యను JavaDocగా మార్చవచ్చు మరియు కొత్త బిల్డ్‌లో లోపం పోయిందని చూడవచ్చు.

బాటమ్ లైన్

ప్రాజెక్ట్‌లో ఉత్పాదకతను పెంచడానికి కోడ్ శైలి ముఖ్యం. భాగస్వామ్య నియమాల ప్రకారం వ్రాసిన అందమైన కోడ్ మీ సహోద్యోగులు దానిని మరింత సులభంగా మరియు త్వరగా అర్థం చేసుకుంటారని మరియు మీకు పెద్దగా విమర్శలను అందించరని హామీ ఇస్తుంది. ఆధునిక అభివృద్ధి సాధనాలతో, శైలి నియమాలకు కట్టుబడి ఉండటం అంత కష్టం కాదు. ఇది నిజమని ఈ సమీక్ష మీకు రుజువు చేసిందని నేను ఆశిస్తున్నాను. సంప్రదాయాన్ని అనుసరించి, అంశంపై కొంచెం అదనపు అంశాలు ఇక్కడ ఉన్నాయి:

• JetBrainsTV నుండి వీడియో: " కోడ్‌ని తనిఖీ చేయండి (IntelliJ IDEA) "
• " గ్రేడిల్ ప్లగిన్‌లతో కోడ్ విశ్లేషణ " యొక్క సమీక్ష
• " ఆటోమేట్ కోడ్ క్వాలిటీ " కోర్సు