1. ప్రారంభకులకు Gitకి వివరణాత్మక గైడ్

ఈ రోజు మనం Git అనే వెర్షన్ కంట్రోల్ సిస్టమ్ గురించి మాట్లాడబోతున్నాం.

ఈ సాధనాన్ని తెలుసుకోకుండా మరియు అర్థం చేసుకోకుండా మీరు నిజంగా పూర్తి స్థాయి ప్రోగ్రామర్ కాలేరు. వాస్తవానికి, నిరంతరంగా పని చేయడానికి మీరు అన్ని Git ఆదేశాలు మరియు లక్షణాలను మీ తలలో ఉంచుకోవాల్సిన అవసరం లేదు. జరుగుతున్న ప్రతిదాన్ని అర్థం చేసుకోవడంలో మీకు సహాయపడే ఆదేశాల సమితిని మీరు తెలుసుకోవాలి.

Git బేసిక్స్

Git అనేది మా కోడ్ కోసం పంపిణీ చేయబడిన సంస్కరణ నియంత్రణ వ్యవస్థ. మనకు అది ఎందుకు అవసరం? జట్లకు వారి పనిని నిర్వహించడానికి ఒక రకమైన వ్యవస్థ అవసరం. కాలానుగుణంగా సంభవించే మార్పులను ట్రాక్ చేయడం అవసరం.

అంటే ఏయే ఫైల్స్ ఎలా మారాయి, ఎలా మారాయి అనేది దశల వారీగా చూడగలగాలి. మీరు ఒకే పని సందర్భంలో ఏమి మారిందో పరిశోధిస్తున్నప్పుడు ఇది చాలా ముఖ్యమైనది, మార్పులను తిరిగి పొందడం సాధ్యమవుతుంది.

కింది పరిస్థితిని ఊహించుకుందాం: మనకు వర్కింగ్ కోడ్ ఉంది, దానిలోని ప్రతిదీ మంచిది, కానీ మేము ఏదైనా మెరుగుపరచాలని లేదా సర్దుబాటు చేయాలని నిర్ణయించుకుంటాము. పెద్ద విషయం ఏమీ లేదు, కానీ మా "అభివృద్ధి" ప్రోగ్రామ్ యొక్క సగం ఫీచర్లను విచ్ఛిన్నం చేసింది మరియు పని చేయడం అసాధ్యం చేసింది. కాబట్టి ఇప్పుడు ఏమిటి? Git లేకుండా, మీరు గంటలు కూర్చుని ఆలోచించవలసి ఉంటుంది, ప్రతిదీ అసలు ఎలా ఉందో గుర్తుంచుకోవడానికి ప్రయత్నిస్తుంది. కానీ Gitతో, మేము నిబద్ధతను వెనక్కి తీసుకుంటాము - అంతే.

లేదా ఒకే సమయంలో ఇద్దరు డెవలపర్‌లు తమ స్వంత కోడ్‌ను మార్చుకుంటే ఏమి చేయాలి? Git లేకుండా, వారు అసలు కోడ్ ఫైల్‌లను కాపీ చేసి, వాటిని విడిగా సవరించుకుంటారు. ఇద్దరూ తమ మార్పులను ప్రధాన డైరెక్టరీకి జోడించాలనుకునే సమయం వస్తుంది. ఈ సందర్భంలో మీరు ఏమి చేస్తారు?

మీరు Git ఉపయోగిస్తే అలాంటి సమస్యలు ఉండవు.

Gitని ఇన్‌స్టాల్ చేస్తోంది

మీ కంప్యూటర్‌లో జావాను ఇన్‌స్టాల్ చేద్దాం ఈ ప్రక్రియ వేర్వేరు ఆపరేటింగ్ సిస్టమ్‌లకు కొద్దిగా భిన్నంగా ఉంటుంది.

విండోస్‌లో ఇన్‌స్టాల్ చేస్తోంది

ఎప్పటిలాగే, మీరు exe ఫైల్‌ను డౌన్‌లోడ్ చేసి రన్ చేయాలి. ఇక్కడ ప్రతిదీ చాలా సులభం: మొదటి Google లింక్‌పై క్లిక్ చేయండి , ఇన్‌స్టాల్ చేయండి మరియు అంతే. దీన్ని చేయడానికి, మేము Windows అందించిన బాష్ కన్సోల్‌ను ఉపయోగిస్తాము.

విండోస్‌లో, మీరు Git Bashని అమలు చేయాలి. ప్రారంభ మెనులో ఇది ఎలా కనిపిస్తుందో ఇక్కడ ఉంది:

ఇప్పుడు ఇది మీరు పని చేయగల కమాండ్ ప్రాంప్ట్.

అక్కడ Gitని తెరవడానికి ప్రతిసారీ ప్రాజెక్ట్‌తో ఉన్న ఫోల్డర్‌కు వెళ్లకుండా ఉండటానికి, మీరు ప్రాజెక్ట్ ఫోల్డర్‌లోని కుడి మౌస్ బటన్‌తో మనకు అవసరమైన మార్గంతో కమాండ్ ప్రాంప్ట్‌ను తెరవవచ్చు:

Linuxలో ఇన్‌స్టాల్ చేస్తోంది

సాధారణంగా Git Linux పంపిణీలలో భాగం మరియు ఇది ఇప్పటికే ఇన్‌స్టాల్ చేయబడింది, ఎందుకంటే ఇది మొదట Linux కెర్నల్ అభివృద్ధి కోసం వ్రాయబడిన సాధనం. కానీ అది లేనప్పుడు పరిస్థితులు ఉన్నాయి. తనిఖీ చేయడానికి, మీరు టెర్మినల్‌ని తెరిచి వ్రాయాలి: git --version. మీకు అర్థమయ్యే సమాధానం వస్తే, ఏదీ ఇన్‌స్టాల్ చేయాల్సిన అవసరం లేదు.

టెర్మినల్ తెరిచి, ఇన్‌స్టాల్ చేయండి. ఉబుంటు కోసం, మీరు వ్రాయాలి: sudo apt-get install git. అంతే: ఇప్పుడు మీరు Gitని ఏదైనా టెర్మినల్‌లో ఉపయోగించవచ్చు.

MacOSలో ఇన్‌స్టాల్ చేస్తోంది

ఇక్కడ కూడా, మీరు ముందుగా Git ఇప్పటికే ఉందో లేదో తనిఖీ చేయాలి (పైన చూడండి, Linuxలో అదే).

మీ వద్ద అది లేకుంటే, దాన్ని పొందడానికి సులభమైన మార్గం తాజా సంస్కరణను డౌన్‌లోడ్ చేయడం . Xcode ఇన్‌స్టాల్ చేయబడితే, Git ఖచ్చితంగా స్వయంచాలకంగా ఇన్‌స్టాల్ చేయబడుతుంది.

Git సెట్టింగ్‌లు

పనిని సమర్పించే వినియోగదారు కోసం Git వినియోగదారు సెట్టింగ్‌లను కలిగి ఉంది. ఇది అర్ధవంతం మరియు అవసరం, ఎందుకంటే కమిట్ సృష్టించబడినప్పుడు రచయిత ఫీల్డ్ కోసం Git ఈ సమాచారాన్ని తీసుకుంటుంది.

కింది ఆదేశాలను అమలు చేయడం ద్వారా మీ అన్ని ప్రాజెక్ట్‌లకు వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను సెటప్ చేయండి:

మీరు నిర్దిష్ట ప్రాజెక్ట్ కోసం రచయితను మార్చవలసి వస్తే (ఉదాహరణకు, వ్యక్తిగత ప్రాజెక్ట్ కోసం), మీరు "--గ్లోబల్"ని తీసివేయవచ్చు. ఇది మాకు ఈ క్రింది వాటిని ఇస్తుంది:

కొంచెం సిద్ధాంతం

టాపిక్‌లోకి ప్రవేశించడానికి, మేము మీకు కొన్ని కొత్త పదాలు మరియు చర్యలను పరిచయం చేయాలి... లేకపోతే, మాట్లాడటానికి ఏమీ ఉండదు. అయితే, ఇది ఆంగ్లం నుండి మాకు వచ్చే పరిభాష, కాబట్టి నేను కుండలీకరణాల్లో అనువాదాలను జోడిస్తాను.

ఏ పదాలు మరియు చర్యలు?

• git రిపోజిటరీ
• కట్టుబడి
• శాఖ
• విలీనం
• గొడవలు
• లాగండి
• పుష్
• కొన్ని ఫైల్‌లను ఎలా విస్మరించాలి (.gitignore)

మరియు అందువలన న.

Gitలో స్థితిగతులు

Git అనేక విగ్రహాలను కలిగి ఉంది, వాటిని అర్థం చేసుకోవాలి మరియు గుర్తుంచుకోవాలి:

• ట్రాక్ చేయబడలేదు
• సవరించబడింది
• రంగస్థలం
• కట్టుబడి

మీరు దీన్ని ఎలా అర్థం చేసుకోవాలి?

ఇవి మన కోడ్‌ని కలిగి ఉన్న ఫైల్‌లకు వర్తించే స్థితి. మరో మాటలో చెప్పాలంటే, వారి జీవిత చక్రం సాధారణంగా ఇలా కనిపిస్తుంది:

• రిపోజిటరీకి సృష్టించబడిన కానీ ఇంకా జోడించబడని ఫైల్ "ట్రాక్ చేయని" స్థితిని కలిగి ఉంటుంది.
• మేము ఇప్పటికే Git రిపోజిటరీకి జోడించిన ఫైల్‌లకు మార్పులు చేసినప్పుడు, వాటి స్థితి "సవరించినది" అవుతుంది.
• మేము మార్చిన ఫైల్‌లలో, మనకు అవసరమైన వాటిని ఎంచుకుంటాము (ఉదాహరణకు, మాకు కంపైల్ చేయబడిన తరగతులు అవసరం లేదు), మరియు ఈ తరగతులు "స్టేజ్డ్" స్థితికి మార్చబడతాయి.
• స్టేజ్డ్ స్టేట్‌లో సిద్ధం చేసిన ఫైల్‌ల నుండి కమిట్ సృష్టించబడుతుంది మరియు Git రిపోజిటరీలోకి వెళుతుంది. ఆ తర్వాత, "స్టేజ్డ్" స్టేటస్‌తో ఫైల్‌లు లేవు. కానీ ఇప్పటికీ "సవరించిన" స్థితి ఉన్న ఫైల్‌లు ఉండవచ్చు.

ఇది ఇలా కనిపిస్తుంది:

నిబద్ధత అంటే ఏమిటి?

సంస్కరణ నియంత్రణ విషయానికి వస్తే కమిట్ అనేది ప్రధాన కార్యక్రమం. నిబద్ధత ప్రారంభమైనప్పటి నుండి చేసిన అన్ని మార్పులు ఇందులో ఉన్నాయి. కమిట్‌లు ఏకంగా లింక్ చేయబడిన జాబితా వలె ఒకదానితో ఒకటి అనుసంధానించబడి ఉంటాయి.

ప్రత్యేకంగా, మొదటి నిబద్ధత ఉంది. రెండవ నిబద్ధత సృష్టించబడినప్పుడు, మొదటిదాని తర్వాత ఏమి వస్తుందో దానికి (రెండవది) తెలుసు. మరియు ఈ పద్ధతిలో, సమాచారాన్ని ట్రాక్ చేయవచ్చు.

ఒక కమిట్ దాని స్వంత సమాచారాన్ని కూడా కలిగి ఉంటుంది, దీనిని మెటాడేటా అని పిలుస్తారు:

• కమిట్ యొక్క ఏకైక ఐడెంటిఫైయర్, దానిని కనుగొనడానికి ఉపయోగించవచ్చు
• దానిని సృష్టించిన కమిట్ రచయిత పేరు
• కమిట్ సృష్టించబడిన తేదీ
• నిబద్ధత సమయంలో ఏమి జరిగిందో వివరించే వ్యాఖ్య

ఇది ఎలా కనిపిస్తుందో ఇక్కడ ఉంది:

శాఖ అంటే ఏమిటి?

కొందరి నిబద్ధతకు బ్రాంచ్ ఒక పాయింటర్. ఒక కమిట్‌కు దాని కంటే ముందు ఏ కమిట్ ఉంటుందో తెలుసు కాబట్టి, ఒక శాఖ ఒక నిబద్ధతను సూచించినప్పుడు, ఆ మునుపటి కమిట్‌లన్నీ దానికి కూడా వర్తిస్తాయి.

దీని ప్రకారం, మీరు ఒకే నిబద్ధతను సూచిస్తూ మీరు ఎన్ని శాఖలను కలిగి ఉండవచ్చో చెప్పగలము.

పని శాఖలలో జరుగుతుంది, కాబట్టి కొత్త కమిట్ సృష్టించబడినప్పుడు, శాఖ దాని పాయింటర్‌ను ఇటీవలి కమిట్‌కి తరలిస్తుంది.

Gitతో ప్రారంభించడం

మీరు స్థానిక రిపోజిటరీతో పాటు రిమోట్‌తో కూడా పని చేయవచ్చు.

అవసరమైన ఆదేశాలను సాధన చేయడానికి, మీరు స్థానిక రిపోజిటరీకి మిమ్మల్ని పరిమితం చేసుకోవచ్చు. ఇది ప్రాజెక్ట్ యొక్క మొత్తం సమాచారాన్ని స్థానికంగా .git ఫోల్డర్‌లో మాత్రమే నిల్వ చేస్తుంది.

మేము రిమోట్ రిపోజిటరీ గురించి మాట్లాడుతున్నట్లయితే, మొత్తం సమాచారం రిమోట్ సర్వర్‌లో ఎక్కడో నిల్వ చేయబడుతుంది: ప్రాజెక్ట్ యొక్క కాపీ మాత్రమే స్థానికంగా నిల్వ చేయబడుతుంది. మీ స్థానిక కాపీకి చేసిన మార్పులు రిమోట్ రిపోజిటరీకి నెట్టబడతాయి (git పుష్).

ఇక్కడ మరియు దిగువ మా చర్చలో, మేము కన్సోల్‌లో Gitతో పని చేయడం గురించి మాట్లాడుతున్నాము. అయితే, మీరు ఒక విధమైన GUI-ఆధారిత పరిష్కారాన్ని ఉపయోగించవచ్చు (ఉదాహరణకు, IntelliJ IDEA), కానీ ముందుగా మీరు ఏ ఆదేశాలను అమలు చేస్తున్నారో మరియు వాటి అర్థం ఏమిటో గుర్తించాలి.

స్థానిక రిపోజిటరీలో Gitతో పని చేస్తోంది

స్థానిక రిపోజిటరీని సృష్టించడానికి, మీరు వ్రాయాలి:

ఇది కన్సోల్ ప్రస్తుత డైరెక్టరీలో దాచిన .git ఫోల్డర్‌ను సృష్టిస్తుంది.

.git ఫోల్డర్ Git రిపోజిటరీ గురించిన మొత్తం సమాచారాన్ని నిల్వ చేస్తుంది. దాన్ని తొలగించవద్దు;)

తరువాత, ఫైల్‌లు ప్రాజెక్ట్‌కి జోడించబడతాయి మరియు వాటికి "ట్రాక్ చేయని" స్థితి కేటాయించబడుతుంది. మీ పని యొక్క ప్రస్తుత స్థితిని తనిఖీ చేయడానికి, దీన్ని వ్రాయండి:

మేము మాస్టర్ బ్రాంచ్‌లో ఉన్నాము మరియు మేము మరొక శాఖకు మారే వరకు ఇక్కడే ఉంటాము.

ఏ ఫైల్‌లు మారాయి కానీ ఇంకా "స్టేజ్డ్" స్థితికి జోడించబడలేదని ఇది చూపుతుంది. వాటిని "స్టేజ్డ్" స్థితికి జోడించడానికి, మీరు "git add" అని వ్రాయాలి. మాకు ఇక్కడ కొన్ని ఎంపికలు ఉన్నాయి, ఉదాహరణకు:

• git add -A — అన్ని ఫైళ్లను "స్టేజ్డ్" స్థితికి జోడించండి
• git add. — ఈ ఫోల్డర్ నుండి అన్ని ఫైల్‌లను మరియు అన్ని సబ్‌ఫోల్డర్‌లను జోడించండి. ముఖ్యంగా మునుపటి మాదిరిగానే;
• git add <file name> — నిర్దిష్ట ఫైల్‌ను జోడిస్తుంది. ఇక్కడ మీరు కొన్ని నమూనా ప్రకారం ఫైల్‌లను జోడించడానికి సాధారణ వ్యక్తీకరణలను ఉపయోగించవచ్చు. ఉదాహరణకు, git add *.java: అంటే మీరు java పొడిగింపుతో ఫైల్‌లను మాత్రమే జోడించాలనుకుంటున్నారు.

మొదటి రెండు ఎంపికలు స్పష్టంగా సరళమైనవి. తాజా జోడింపుతో విషయాలు మరింత ఆసక్తికరంగా మారాయి, కాబట్టి వ్రాద్దాం:

స్థితిని తనిఖీ చేయడానికి, మేము ఇప్పటికే మనకు తెలిసిన ఆదేశాన్ని ఉపయోగిస్తాము:

సాధారణ వ్యక్తీకరణ సరిగ్గా పని చేసిందని మీరు ఇక్కడ చూడవచ్చు: test_resource.txt ఇప్పుడు "స్టేజ్డ్" స్థితిని కలిగి ఉంది.

చివరకు, స్థానిక రిపోజిటరీతో పని చేయడానికి చివరి దశ (రిమోట్ రిపోజిటరీతో పని చేస్తున్నప్పుడు మరొకటి ఉంది;)) - కొత్త నిబద్ధతను సృష్టించడం:

తదుపరిది బ్రాంచ్‌లోని కమిట్ హిస్టరీని చూడటం కోసం గొప్ప ఆదేశం. దానిని ఉపయోగించుకుందాం:

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

ఇంకా నిద్రపోని ఒక పరిశోధనాత్మక పాఠకుడు GitTest.java ఫైల్‌కి ఏమైంది అని ఆలోచిస్తూ ఉండవచ్చు. ఇప్పుడే తెలుసుకుందాం. దీన్ని చేయడానికి, మేము ఉపయోగిస్తాము:

మీరు చూడగలిగినట్లుగా, ఇది ఇప్పటికీ "ట్రాక్ చేయబడలేదు" మరియు రెక్కలలో వేచి ఉంది. కానీ మనం దీన్ని ప్రాజెక్ట్‌కి అస్సలు జోడించకూడదనుకుంటే? కొన్నిసార్లు అలా జరుగుతుంది.

విషయాలను మరింత ఆసక్తికరంగా చేయడానికి, ఇప్పుడు మన test_resource.txt ఫైల్‌ని మార్చడానికి ప్రయత్నిద్దాం. అక్కడ కొంత వచనాన్ని జోడించి, స్థితిని తనిఖీ చేద్దాం:

ఇక్కడ మీరు "ట్రాక్ చేయని" మరియు "సవరించిన" స్థితిగతుల మధ్య వ్యత్యాసాన్ని స్పష్టంగా చూడవచ్చు.

GitTest.java "ట్రాక్ చేయబడలేదు", అయితే test_resource.txt "మార్చబడింది".

ఇప్పుడు మేము సవరించిన స్థితిలో ఫైల్‌లను కలిగి ఉన్నాము, మేము వాటికి చేసిన మార్పులను పరిశీలించవచ్చు. కింది ఆదేశాన్ని ఉపయోగించి ఇది చేయవచ్చు:

అంటే, నేను మా టెక్స్ట్ ఫైల్‌కి జోడించిన వాటిని మీరు ఇక్కడ స్పష్టంగా చూడవచ్చు: హలో వరల్డ్!

టెక్స్ట్ ఫైల్‌కి మన మార్పులను జోడించి, నిబద్ధతను సృష్టించండి:

అన్ని కమిట్‌లను చూడటానికి, వ్రాయండి:

మీరు గమనిస్తే, మాకు ఇప్పుడు రెండు కమిట్‌లు ఉన్నాయి.

మేము GitTest.javaని అదే విధంగా జోడిస్తాము. ఇక్కడ వ్యాఖ్యలు లేవు, కేవలం ఆదేశాలు:

.gitignoreతో పని చేస్తున్నారు

స్పష్టంగా, మేము రిపోజిటరీలో సోర్స్ కోడ్ మాత్రమే ఉంచాలనుకుంటున్నాము మరియు మరేమీ లేదు. కాబట్టి ఇంకా ఏమి ఉండవచ్చు? కనిష్టంగా, సంకలనం చేయబడిన తరగతులు మరియు/లేదా డెవలప్‌మెంట్ పరిసరాల ద్వారా రూపొందించబడిన ఫైల్‌లు.

వాటిని విస్మరించమని Gitకి చెప్పడానికి, మనం ఒక ప్రత్యేక ఫైల్‌ని సృష్టించాలి. ఇలా చేయండి: ప్రాజెక్ట్ యొక్క రూట్‌లో .gitignore అనే ఫైల్‌ను సృష్టించండి. ఈ ఫైల్‌లోని ప్రతి పంక్తి విస్మరించాల్సిన నమూనాను సూచిస్తుంది.

ఈ ఉదాహరణలో, .gitignore ఫైల్ ఇలా కనిపిస్తుంది:

ఒకసారి చూద్దాము:

• .class పొడిగింపుతో అన్ని ఫైల్‌లను విస్మరించడమే మొదటి పంక్తి
• రెండవ పంక్తి "టార్గెట్" ఫోల్డర్ మరియు అది కలిగి ఉన్న ప్రతిదాన్ని విస్మరించడం
• మూడవ పంక్తి .iml పొడిగింపుతో అన్ని ఫైల్‌లను విస్మరించడం
• నాల్గవ పంక్తి .idea ఫోల్డర్‌ను విస్మరించడమే

ఒక ఉదాహరణను ఉపయోగించి ప్రయత్నిద్దాం. ఇది ఎలా పని చేస్తుందో చూడటానికి, కంపైల్ చేసిన GitTest.classని ప్రాజెక్ట్‌కి జోడించి ప్రాజెక్ట్ స్థితిని తనిఖీ చేద్దాం:

స్పష్టంగా, మేము అనుకోకుండా కంపైల్డ్ క్లాస్‌ని ప్రాజెక్ట్‌కి (git add -A ఉపయోగించి) జోడించకూడదనుకుంటున్నాము. దీన్ని చేయడానికి, .gitignore ఫైల్‌ను సృష్టించండి మరియు ముందుగా వివరించిన ప్రతిదాన్ని జోడించండి:

ఇప్పుడు ప్రాజెక్ట్‌కు .gitignore ఫైల్‌ను జోడించడానికి నిబద్ధతను ఉపయోగిస్తాము:

మరియు ఇప్పుడు నిజం యొక్క క్షణం: మేము Git రిపోజిటరీకి జోడించదలుచుకోని "ట్రాక్ చేయని" GitTest.class అనే సంకలన తరగతిని కలిగి ఉన్నాము.

ఇప్పుడు మనం .gitignore ఫైల్ యొక్క ప్రభావాలను చూడాలి:

పర్ఫెక్ట్! .gitignore +1 :)

శాఖలతో పని చేస్తున్నారు

సహజంగానే, కేవలం ఒక శాఖలో పని చేయడం ఒంటరి డెవలపర్‌లకు అసౌకర్యంగా ఉంటుంది మరియు ఒక బృందంలో ఒకటి కంటే ఎక్కువ మంది వ్యక్తులు ఉన్నప్పుడు అది అసాధ్యం. అందుకే మాకు శాఖలు ఉన్నాయి.

ఒక శాఖ కేవలం కమిట్ చేయడానికి ఒక కదిలే పాయింటర్.

ఈ భాగంలో, మేము వివిధ శాఖలలో పని చేయడం గురించి అన్వేషిస్తాము: మార్పులను ఒక శాఖ నుండి మరొక శాఖలోకి ఎలా విలీనం చేయాలి, ఎలాంటి వైరుధ్యాలు తలెత్తవచ్చు మరియు మరెన్నో.

రిపోజిటరీలోని అన్ని శాఖల జాబితాను చూడటానికి మరియు మీరు దేనిలో ఉన్నారో అర్థం చేసుకోవడానికి, మీరు వ్రాయాలి:

మాకు ఒక మాస్టర్ బ్రాంచ్ మాత్రమే ఉందని మీరు చూడవచ్చు. దాని ముందు ఉన్న నక్షత్రం మనం అందులో ఉన్నామని సూచిస్తుంది. మార్గం ద్వారా, మీరు మేము ఏ శాఖలో ఉన్నారో తెలుసుకోవడానికి "git స్థితి" ఆదేశాన్ని కూడా ఉపయోగించవచ్చు.

అప్పుడు శాఖలను సృష్టించడానికి అనేక ఎంపికలు ఉన్నాయి (మరిన్ని ఉండవచ్చు - ఇవి నేను ఉపయోగించేవి):

• మేము ఉన్న శాఖ ఆధారంగా కొత్త శాఖను సృష్టించండి (99% కేసులు)
• నిర్దిష్ట కమిట్ (1% కేసులు) ఆధారంగా శాఖను సృష్టించండి

నిర్దిష్ట నిబద్ధత ఆధారంగా ఒక శాఖను క్రియేట్ చేద్దాం

మేము కమిట్ యొక్క ప్రత్యేక ఐడెంటిఫైయర్‌పై ఆధారపడతాము. దానిని కనుగొనడానికి, మేము వ్రాస్తాము:

మేము "హలో వరల్డ్ జోడించబడింది..." అనే వ్యాఖ్యతో నిబద్ధతను హైలైట్ చేసాము, దీని ప్రత్యేక గుర్తింపు 6c44e53d06228f888f2f454d3cb8c1c976dd73f8. మేము ఈ నిబద్ధత నుండి ప్రారంభమయ్యే "అభివృద్ధి" శాఖను సృష్టించాలనుకుంటున్నాము. దీన్ని చేయడానికి, మేము వ్రాస్తాము:

మాస్టర్ బ్రాంచ్ నుండి మొదటి రెండు కమిట్‌లతో మాత్రమే ఒక శాఖ సృష్టించబడుతుంది. దీన్ని ధృవీకరించడానికి, మేము ముందుగా వేరే బ్రాంచ్‌కి మారాలని నిర్ధారిస్తాము మరియు అక్కడ కమిట్‌ల సంఖ్యను పరిశీలిస్తాము:

మరియు ఊహించిన విధంగా, మాకు రెండు కమిట్‌లు ఉన్నాయి. చెప్పాలంటే, ఇక్కడ ఒక ఆసక్తికరమైన అంశం ఉంది: ఈ బ్రాంచ్‌లో ఇంకా .gitignore ఫైల్ లేదు, కాబట్టి మా కంపైల్డ్ ఫైల్ (GitTest.class) ఇప్పుడు "ట్రాక్ చేయని" స్థితితో హైలైట్ చేయబడింది.

ఇప్పుడు మనం ఇలా వ్రాయడం ద్వారా మా శాఖలను మళ్లీ సమీక్షించవచ్చు:

రెండు శాఖలు ఉన్నాయని మీరు చూడవచ్చు: "మాస్టర్" మరియు "డెవలప్మెంట్". మేము ప్రస్తుతం అభివృద్ధిలో ఉన్నాము.

ప్రస్తుతం ఉన్న శాఖ ఆధారంగా ఒక శాఖను క్రియేట్ చేద్దాం

ఒక శాఖను సృష్టించడానికి రెండవ మార్గం దానిని మరొక దాని నుండి సృష్టించడం. మేము మాస్టర్ బ్రాంచ్ ఆధారంగా ఒక శాఖను సృష్టించాలనుకుంటున్నాము. మొదట, మేము దానికి మారాలి మరియు తదుపరి దశ కొత్తదాన్ని సృష్టించడం. ఒకసారి చూద్దాము:

• git చెక్అవుట్ మాస్టర్ — మాస్టర్ బ్రాంచ్‌కి మారండి
• git స్థితి — మేము నిజానికి మాస్టర్ బ్రాంచ్‌లో ఉన్నామని ధృవీకరించండి

మేము మాస్టర్ బ్రాంచ్‌కి మారినట్లు మీరు ఇక్కడ చూడవచ్చు, .gitignore ఫైల్ అమలులో ఉంది మరియు కంపైల్డ్ క్లాస్ ఇకపై "ట్రాక్ చేయబడలేదు" అని హైలైట్ చేయబడదు.

ఇప్పుడు మేము మాస్టర్ బ్రాంచ్ ఆధారంగా కొత్త శాఖను సృష్టిస్తాము:

ఈ బ్రాంచ్ "మాస్టర్" లాంటిదేనా అని మీకు ఖచ్చితంగా తెలియకుంటే, మీరు "git log"ని అమలు చేయడం ద్వారా మరియు అన్ని కమిట్‌లను చూడటం ద్వారా సులభంగా తనిఖీ చేయవచ్చు. వాటిలో నాలుగు ఉండాలి.

సంఘర్షణ పరిష్కారం

సంఘర్షణ అంటే ఏమిటో అన్వేషించే ముందు, ఒక శాఖను మరొక శాఖలో విలీనం చేయడం గురించి మాట్లాడాలి.

ఈ చిత్రం ఒక శాఖను మరొకదానికి విలీనం చేసే ప్రక్రియను వర్ణిస్తుంది:

ఇక్కడ, మాకు ప్రధాన శాఖ ఉంది. ఏదో ఒక సమయంలో, ప్రధాన శాఖ నుండి ద్వితీయ శాఖ సృష్టించబడుతుంది మరియు తరువాత సవరించబడుతుంది. పని పూర్తయిన తర్వాత, మేము ఒక శాఖను మరొకదానిలో విలీనం చేయాలి.

మా ఉదాహరణలో, మేము ఫీచర్/అప్‌డేట్-txt-ఫైల్స్ శాఖను సృష్టించాము. శాఖ పేరు సూచించినట్లుగా, మేము వచనాన్ని నవీకరిస్తున్నాము.

ఇప్పుడు మనం ఈ పని కోసం కొత్త నిబద్ధతను సృష్టించాలి:

ఇప్పుడు, మనం ఫీచర్/అప్‌డేట్-txt-ఫైల్స్ బ్రాంచ్‌ని మాస్టర్‌లో విలీనం చేయాలనుకుంటే, మనం మాస్టర్‌కి వెళ్లి "git merge feature/update-txt-files" అని వ్రాయాలి:

ఫలితంగా, మాస్టర్ బ్రాంచ్ ఇప్పుడు ఫీచర్/అప్‌డేట్-txt-ఫైల్స్‌కు జోడించబడిన కమిట్‌ను కూడా కలిగి ఉంది.

ఈ ఫంక్షనాలిటీ జోడించబడింది, కాబట్టి మీరు ఫీచర్ బ్రాంచ్‌ను తొలగించవచ్చు. దీన్ని చేయడానికి, మేము వ్రాస్తాము:

పరిస్థితిని క్లిష్టతరం చేద్దాం: ఇప్పుడు మీరు txt ఫైల్‌ను మళ్లీ మార్చాల్సిన అవసరం ఉందని చెప్పండి. అయితే ఇప్పుడు మాస్టర్ బ్రాంచ్‌లోనూ ఈ ఫైల్‌ను మార్చనున్నారు. మరో మాటలో చెప్పాలంటే, ఇది సమాంతరంగా మారుతుంది. మేము మా కొత్త కోడ్‌ను మాస్టర్ బ్రాంచ్‌లో విలీనం చేయాలనుకున్నప్పుడు ఏమి చేయాలో Git గుర్తించలేకపోతుంది.

మేము మాస్టర్ ఆధారంగా కొత్త బ్రాంచ్‌ని సృష్టిస్తాము, text_resource.txtకి మార్పులు చేస్తాము మరియు ఈ పని కోసం నిబద్ధతను సృష్టిస్తాము:

... మేము ఫైల్‌లో మార్పులు చేస్తాము

మాస్టర్ బ్రాంచ్‌కి వెళ్లి, ఫీచర్ బ్రాంచ్‌లోని అదే లైన్‌లో ఈ టెక్స్ట్ ఫైల్‌ను కూడా అప్‌డేట్ చేయండి:

… మేము test_resource.txtని నవీకరించాము

మరియు ఇప్పుడు అత్యంత ఆసక్తికరమైన అంశం: మేము ఫీచర్/యాడ్-హెడర్ బ్రాంచ్ నుండి మాస్టర్‌కు మార్పులను విలీనం చేయాలి. మేము మాస్టర్ బ్రాంచ్‌లో ఉన్నాము, కాబట్టి మేము మాత్రమే వ్రాయాలి:

కానీ ఫలితం test_resource.txt ఫైల్‌లో వైరుధ్యంగా ఉంటుంది:

ఈ కోడ్‌ను ఎలా విలీనం చేయాలో Git స్వంతంగా నిర్ణయించుకోలేదని ఇక్కడ మనం చూడవచ్చు. మేము మొదట సంఘర్షణను పరిష్కరించాలని, ఆపై మాత్రమే కట్టుబడి ఉండాలని ఇది మాకు చెబుతుంది.

అలాగే. మేము టెక్స్ట్ ఎడిటర్‌లో వైరుధ్యంతో ఫైల్‌ని తెరిచి చూడండి:

Git ఇక్కడ ఏమి చేసిందో అర్థం చేసుకోవడానికి, మనం ఏ మార్పులు చేసామో మరియు ఎక్కడ చేసామో గుర్తుంచుకోవాలి, ఆపై సరిపోల్చండి:

1. మాస్టర్ బ్రాంచ్‌లో ఈ లైన్‌లో ఉన్న మార్పులు "<<<<<<< HEAD" మరియు "=======" మధ్య కనుగొనబడ్డాయి.
2. ఫీచర్/యాడ్-హెడర్ బ్రాంచ్‌లో ఉన్న మార్పులు "========" మరియు ">>>>>>> ఫీచర్/యాడ్-హెడర్" మధ్య కనుగొనబడ్డాయి.

ఫైల్‌లోని ఈ ప్రదేశంలో విలీనాన్ని ఎలా నిర్వహించాలో అది గుర్తించలేకపోయిందని Git మాకు ఈ విధంగా చెబుతుంది. ఇది వివిధ శాఖల నుండి ఈ విభాగాన్ని రెండు భాగాలుగా విభజించింది మరియు విలీన సంఘర్షణను మనమే పరిష్కరించుకోమని ఆహ్వానిస్తుంది.

సరిపోయింది. నేను "హెడర్" అనే పదాన్ని మాత్రమే వదిలి ప్రతిదీ తీసివేయాలని ధైర్యంగా నిర్ణయించుకున్నాను:

మార్పుల స్థితిని చూద్దాం. వివరణ కొద్దిగా భిన్నంగా ఉంటుంది. "సవరించిన" స్థితికి బదులుగా, మేము "విలీనం" చేసాము. కాబట్టి మనం ఐదవ స్థితిని ప్రస్తావించగలమా? ఇది అవసరమని నేను అనుకోను. చూద్దాం:

ఇది ప్రత్యేకమైన, అసాధారణమైన కేసు అని మనం ఒప్పించగలము. ముందుకు సాగిద్దాము:

వివరణ "git commit" అని మాత్రమే వ్రాయమని సూచించడాన్ని మీరు గమనించవచ్చు. దీన్ని వ్రాయడానికి ప్రయత్నిద్దాం:

మరియు అదే విధంగా, మేము చేసాము - మేము కన్సోల్‌లో సంఘర్షణను పరిష్కరించాము.

అయితే, ఇంటిగ్రేటెడ్ డెవలప్‌మెంట్ పరిసరాలలో దీన్ని కొంచెం సులభంగా చేయవచ్చు. ఉదాహరణకు, IntelliJ IDEAలో, ప్రతిదీ చాలా బాగా సెటప్ చేయబడింది, మీరు దానిలోనే అవసరమైన అన్ని చర్యలను చేయవచ్చు. కానీ IDEలు చాలా పనులు "అండర్ ది హుడ్" చేస్తాయి మరియు అక్కడ సరిగ్గా ఏమి జరుగుతుందో మనకు తరచుగా అర్థం కాదు. మరియు అవగాహన లేనప్పుడు, సమస్యలు తలెత్తుతాయి.

రిమోట్ రిపోజిటరీలతో పని చేస్తోంది

రిమోట్ రిపోజిటరీతో పని చేయడానికి అవసరమైన మరికొన్ని ఆదేశాలను గుర్తించడం చివరి దశ.

నేను చెప్పినట్లుగా, రిమోట్ రిపోజిటరీ అనేది రిపోజిటరీ నిల్వ చేయబడిన ప్రదేశం మరియు మీరు దానిని క్లోన్ చేయవచ్చు.

ఎలాంటి రిమోట్ రిపోజిటరీలు ఉన్నాయి? ఉదాహరణలు:

• GitHub అనేది రిపోజిటరీలు మరియు సహకార అభివృద్ధి కోసం అతిపెద్ద నిల్వ వేదిక.
• GitLab అనేది ఓపెన్ సోర్స్‌తో DevOps జీవితచక్రం కోసం వెబ్ ఆధారిత సాధనం. ఇది దాని స్వంత వికీ, బగ్ ట్రాకింగ్ సిస్టమ్, CI/CD పైప్‌లైన్ మరియు ఇతర ఫంక్షన్‌లతో కోడ్ రిపోజిటరీలను నిర్వహించడానికి Git-ఆధారిత వ్యవస్థ.
• BitBucket అనేది మెర్క్యురియల్ మరియు Git వెర్షన్ నియంత్రణ వ్యవస్థల ఆధారంగా ప్రాజెక్ట్ హోస్టింగ్ మరియు సహకార అభివృద్ధి కోసం ఒక వెబ్ సేవ. ఒక సమయంలో ఇది ఉచిత ప్రైవేట్ రిపోజిటరీలను అందించడంలో GitHub కంటే పెద్ద ప్రయోజనాన్ని కలిగి ఉంది. గత సంవత్సరం, GitHub కూడా ఈ సామర్థ్యాన్ని అందరికీ ఉచితంగా పరిచయం చేసింది.
• మరియు అందువలన న…

రిమోట్ రిపోజిటరీతో పని చేస్తున్నప్పుడు, ముందుగా చేయవలసిన పని మీ స్థానిక రిపోజిటరీకి ప్రాజెక్ట్‌ను క్లోన్ చేయడం.

దీని కోసం, మేము స్థానికంగా తయారు చేసిన ప్రాజెక్ట్‌ను ఎగుమతి చేసాము ఇప్పుడు ప్రతి ఒక్కరూ దీన్ని వ్రాయడం ద్వారా తమ కోసం క్లోన్ చేసుకోవచ్చు:

ప్రాజెక్ట్ యొక్క పూర్తి స్థానిక కాపీ ఇప్పుడు ఉంది. ప్రాజెక్ట్ యొక్క స్థానిక కాపీ తాజాదని నిర్ధారించుకోవడానికి, మీరు వ్రాయడం ద్వారా ప్రాజెక్ట్‌ను తీసివేయాలి:

మా విషయంలో, ప్రస్తుతం రిమోట్ రిపోజిటరీలో ఏదీ మారలేదు, కాబట్టి ప్రతిస్పందన: ఇప్పటికే తాజాగా ఉంది.

కానీ మనం రిమోట్ రిపోజిటరీకి ఏవైనా మార్పులు చేస్తే, వాటిని లాగిన తర్వాత లోకల్ అప్‌డేట్ చేయబడుతుంది.

చివరకు, డేటాను రిమోట్ రిపోజిటరీకి నెట్టడం చివరి ఆదేశం. మనం స్థానికంగా ఏదైనా చేసి, దాన్ని రిమోట్ రిపోజిటరీకి పంపాలనుకున్నప్పుడు, ముందుగా స్థానికంగా కొత్త కమిట్‌ని సృష్టించాలి. దీన్ని ప్రదర్శించడానికి, మన టెక్స్ట్ ఫైల్‌కు వేరొకదాన్ని జోడిద్దాం:

ఇప్పుడు మనకు చాలా సాధారణమైనది — మేము ఈ పని కోసం ఒక నిబద్ధతను సృష్టిస్తాము:

దీన్ని రిమోట్ రిపోజిటరీకి నెట్టడానికి ఆదేశం:

ప్రస్తుతానికి అంతే!

2. IntelliJ IDEAలో Gitతో ఎలా పని చేయాలి

ఈ భాగంలో, మీరు IntelliJ IDEAలో Gitతో ఎలా పని చేయాలో నేర్చుకుంటారు.

అవసరమైన ఇన్‌పుట్‌లు:

1. మునుపటి భాగాన్ని చదవండి, అనుసరించండి మరియు అర్థం చేసుకోండి. ప్రతిదీ సెట్ చేయబడిందని మరియు సిద్ధంగా ఉందని నిర్ధారించుకోవడానికి ఇది సహాయపడుతుంది.
2. IntelliJ IDEAని ఇన్‌స్టాల్ చేయండి. ఇక్కడ ప్రతిదీ క్రమంలో ఉండాలి :)
3. పూర్తి నైపుణ్యం సాధించడానికి ఒక గంట కేటాయించండి.

Git గురించిన కథనం కోసం నేను ఉపయోగించిన డెమో ప్రాజెక్ట్‌తో పని చేద్దాం .

ప్రాజెక్ట్‌ను స్థానికంగా క్లోన్ చేయండి

ఇక్కడ రెండు ఎంపికలు ఉన్నాయి:

1. మీరు ఇప్పటికే GitHub ఖాతాను కలిగి ఉంటే మరియు తర్వాత ఏదైనా నెట్టాలనుకుంటే, ప్రాజెక్ట్‌ను ఫోర్క్ చేసి, మీ స్వంత కాపీని క్లోన్ చేయడం మంచిది. ఫోర్క్ వర్క్‌ఫ్లో యొక్క ఉదాహరణ అనే శీర్షిక క్రింద మరొక కథనంలో ఫోర్క్‌ను ఎలా సృష్టించాలో మీరు చదువుకోవచ్చు .
2. రిపోజిటరీని క్లోన్ చేయండి మరియు మొత్తం విషయాన్ని సర్వర్‌కు నెట్టగల సామర్థ్యం లేకుండా స్థానికంగా ప్రతిదీ చేయండి.

GitHub నుండి ప్రాజెక్ట్‌ను క్లోన్ చేయడానికి, మీరు ప్రాజెక్ట్ లింక్‌ని కాపీ చేసి, IntelliJ IDEAకి పాస్ చేయాలి:

1. ప్రాజెక్ట్ చిరునామాను కాపీ చేయండి:

2. IntelliJ IDEAని తెరిచి, "వెర్షన్ కంట్రోల్ నుండి పొందండి" ఎంచుకోండి:

3. ప్రాజెక్ట్ చిరునామాను కాపీ చేసి అతికించండి:

4. మీరు IntelliJ IDEA ప్రాజెక్ట్‌ని సృష్టించమని ప్రాంప్ట్ చేయబడతారు. ఆఫర్‌ను అంగీకరించండి:

5. బిల్డ్ సిస్టమ్ లేనందున, మేము "ఇప్పటికే ఉన్న మూలాల నుండి ప్రాజెక్ట్‌ను సృష్టించు" ఎంచుకుంటాము:

6. తర్వాత మీరు ఈ అందమైన స్క్రీన్‌ని చూస్తారు:

ఇప్పుడు మేము క్లోనింగ్‌ని కనుగొన్నాము, మీరు చుట్టూ పరిశీలించవచ్చు.

Git UIగా IntelliJ IDEAలో మొదటి చూపు

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

మొదట, మేము దిగువ ఎడమ మూలలో సంస్కరణ నియంత్రణ పేన్‌ని కలిగి ఉన్నాము. ఇక్కడ మీరు అన్ని స్థానిక మార్పులను కనుగొనవచ్చు మరియు కమిట్‌ల జాబితాను పొందవచ్చు ("git log"కి సారూప్యంగా ఉంటుంది).

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

అదనంగా, మీరు నిజమైన మార్పులను చూడవచ్చు. అక్కడ ఒక వివాదం పరిష్కరించబడినట్లు కూడా మనం చూస్తున్నాము. IDEA కూడా దీన్ని చాలా బాగా ప్రదర్శిస్తుంది.

ఈ కమిట్ సమయంలో మార్చబడిన ఫైల్‌పై మీరు డబుల్ క్లిక్ చేస్తే, వివాదం ఎలా పరిష్కరించబడిందో మేము చూస్తాము:

ఎడమ మరియు కుడి వైపున మేము ఒకే ఫైల్ యొక్క రెండు వెర్షన్‌లను కలిగి ఉన్నామని మేము గమనించాము. మరియు మధ్యలో, మేము తుది విలీన ఫలితాన్ని కలిగి ఉన్నాము.

ప్రాజెక్ట్‌లో అనేక శాఖలు, కమిట్‌లు మరియు వినియోగదారులు ఉన్నప్పుడు, మీరు శాఖ, వినియోగదారు మరియు తేదీల వారీగా విడిగా వెతకాలి:

ప్రారంభించడానికి ముందు, మనం ఏ శాఖలో ఉన్నామో ఎలా అర్థం చేసుకోవాలో వివరించడం కూడా విలువైనదే.

దిగువ కుడి మూలలో, "Git: master" అని లేబుల్ చేయబడిన బటన్ ఉంది. "Git:" అనేది ప్రస్తుత శాఖ. మీరు బటన్‌ను క్లిక్ చేస్తే, మీరు చాలా ఉపయోగకరమైన పనులను చేయవచ్చు: మరొక శాఖకు మారండి, కొత్తదాన్ని సృష్టించండి, ఇప్పటికే ఉన్న దాని పేరు మార్చండి మరియు మొదలైనవి.

రిపోజిటరీతో పని చేస్తోంది

ఉపయోగకరమైన హాట్‌కీలు

భవిష్యత్ పని కోసం, మీరు చాలా ఉపయోగకరమైన కొన్ని హాట్‌కీలను గుర్తుంచుకోవాలి:

1. CTRL+T — రిమోట్ రిపోజిటరీ (git పుల్) నుండి తాజా మార్పులను పొందండి.
2. CTRL+K — నిబద్ధతను సృష్టించండి / ప్రస్తుత మార్పులన్నింటినీ చూడండి. ఇందులో ట్రాక్ చేయని మరియు సవరించబడిన ఫైల్‌లు (git కమిట్) రెండూ ఉంటాయి.
3. CTRL+SHIFT+K — ఇది రిమోట్ రిపోజిటరీకి మార్పులను నెట్టడానికి ఆదేశం. స్థానికంగా సృష్టించబడిన మరియు ఇంకా రిమోట్ రిపోజిటరీలో లేని అన్ని కమిట్‌లు పుష్ చేయబడతాయి (git పుష్).
4. ALT+CTRL+Z — స్థానిక రిపోజిటరీలో సృష్టించబడిన చివరి కమిట్ స్థితికి నిర్దిష్ట ఫైల్‌లో రోల్‌బ్యాక్ మార్పులు. మీరు ఎగువ ఎడమ మూలలో మొత్తం ప్రాజెక్ట్‌ను ఎంచుకుంటే, మీరు అన్ని ఫైల్‌లలో మార్పులను వెనక్కి తీసుకోవచ్చు.

మనకేం కావాలి?

పనిని పూర్తి చేయడానికి, మేము ప్రతిచోటా ఉపయోగించే ప్రాథమిక దృష్టాంతాన్ని నేర్చుకోవాలి.

ప్రత్యేక శాఖలో కొత్త కార్యాచరణను అమలు చేసి, దానిని రిమోట్ రిపోజిటరీకి నెట్టడం లక్ష్యం (అప్పుడు మీరు ప్రధాన శాఖకు పుల్ అభ్యర్థనను కూడా సృష్టించాలి, కానీ అది ఈ పాఠం యొక్క పరిధికి మించినది).

దీన్ని చేయడానికి ఏమి అవసరం?

1. ప్రధాన శాఖలో అన్ని ప్రస్తుత మార్పులను పొందండి (ఉదాహరణకు, "మాస్టర్").

2. ఈ ప్రధాన శాఖ నుండి, మీ పని కోసం ప్రత్యేక శాఖను సృష్టించండి.

3. కొత్త కార్యాచరణను అమలు చేయండి.

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

   మీరు దీన్ని ఎందుకు చేయాలని ఆలోచిస్తున్నారా? ఇది మంచి మర్యాద మరియు మీ శాఖను స్థానిక రిపోజిటరీకి నెట్టిన తర్వాత సంఘర్షణలు జరగకుండా నిరోధిస్తుంది (వాస్తవానికి, వైరుధ్యాలు ఇప్పటికీ సంభవించే అవకాశం ఉంది, కానీ అది చాలా చిన్నదిగా మారుతుంది).

5. మీ మార్పులను రిమోట్ రిపోజిటరీకి పుష్ చేయండి.

రిమోట్ సర్వర్ నుండి మార్పులను ఎలా పొందాలి?

మేము కొత్త నిబద్ధతతో READMEకి వివరణను జోడించాము మరియు ఈ మార్పులను పొందాలనుకుంటున్నాము. స్థానిక రిపోజిటరీలో మరియు రిమోట్‌లో మార్పులు చేసినట్లయితే, విలీనం మరియు రీబేస్ మధ్య ఎంచుకోవడానికి మేము ఆహ్వానించబడ్డాము. మేము విలీనం చేయడానికి ఎంచుకుంటాము.

CTRL+Tని నమోదు చేయండి :

README ఎలా మారిందో మీరు ఇప్పుడు చూడవచ్చు, అనగా రిమోట్ రిపోజిటరీ నుండి మార్పులు లాగబడ్డాయి మరియు దిగువ కుడి మూలలో మీరు సర్వర్ నుండి వచ్చిన మార్పుల యొక్క అన్ని వివరాలను చూడవచ్చు.

మాస్టర్ ఆధారంగా కొత్త శాఖను సృష్టించండి

ఇక్కడ ప్రతిదీ సులభం.

దిగువ కుడి మూలకు వెళ్లి, Git: master క్లిక్ చేయండి . ఎంచుకోండి + కొత్త శాఖ .

ఎంపిక చేసిన చెక్అవుట్ బ్రాంచ్ చెక్‌బాక్స్‌ని వదిలి , కొత్త బ్రాంచ్ పేరును నమోదు చేయండి. మా విషయంలో: ఇది రీడ్‌మీ-ఇంప్రూవర్ అవుతుంది .

Git: master అప్పుడు Git: readme-improver కి మారుతుంది .

సమాంతర పనిని అనుకరిద్దాం

విభేదాలు కనిపించాలంటే, ఎవరైనా వాటిని సృష్టించాలి.

మేము బ్రౌజర్ ద్వారా కొత్త కమిట్‌తో READMEని ఎడిట్ చేస్తాము, తద్వారా సమాంతర పనిని అనుకరిస్తాము. మనం పని చేస్తున్నప్పుడు అదే ఫైల్‌లో ఎవరో మార్పులు చేసినట్లుగా ఉంది. ఫలితంగా సంఘర్షణ ఉంటుంది. మేము లైన్ 10 నుండి "పోల్నోస్ట్" అనే పదాన్ని తీసివేస్తాము.

మా కార్యాచరణను అమలు చేయండి

READMEని మార్చడం మరియు కొత్త కథనానికి వివరణను జోడించడం మా పని. అంటే, Gitలో పని IntelliJ IDEA ద్వారా జరుగుతుంది. దీన్ని జోడించండి:

మార్పులు పూర్తయ్యాయి. ఇప్పుడు మనం ఒక నిబద్ధతను సృష్టించవచ్చు. CTRL+K నొక్కండి , ఇది మాకు అందిస్తుంది:

నిబద్ధతను సృష్టించే ముందు, ఈ విండో అందించే వాటిని మనం నిశితంగా పరిశీలించాలి.

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

మేము README మార్చబడిందని వ్రాసి, నిబద్ధతను సృష్టించండి. కమిట్ పేరుతో దిగువ ఎడమ మూలలో హెచ్చరిక పాప్ అప్ అవుతుంది:

ప్రధాన శాఖ మార్చబడిందో లేదో తనిఖీ చేయండి

మేము మా పనిని పూర్తి చేసాము. ఇది పనిచేస్తుంది. పరీక్షలు రాశాం. అంతా బాగానే ఉంది. కానీ సర్వర్‌కి నెట్టడానికి ముందు, ఈలోపు మెయిన్ బ్రాంచ్‌లో ఏమైనా మార్పులు ఉన్నాయో లేదో తనిఖీ చేయాలి. అది ఎలా జరుగుతుంది? చాలా సులభంగా: మీ తర్వాత ఎవరైనా ఒక పనిని స్వీకరిస్తారు మరియు మీరు మీ పనిని పూర్తి చేయడం కంటే వేగంగా ఎవరైనా పూర్తి చేస్తారు.

కాబట్టి మనం మాస్టర్ బ్రాంచ్‌కి వెళ్లాలి. దీన్ని చేయడానికి, దిగువ స్క్రీన్‌షాట్‌లో దిగువ కుడి మూలలో చూపిన దాన్ని మనం చేయాలి:

మాస్టర్ బ్రాంచ్‌లో, రిమోట్ సర్వర్ నుండి తాజా మార్పులను పొందడానికి CTRL+T నొక్కండి. మార్పులను చూస్తే, ఏమి జరిగిందో మీరు సులభంగా చూడవచ్చు:

"fully" అనే పదం తీసివేయబడింది. బహుశా మార్కెటింగ్ నుండి ఎవరైనా అలా వ్రాయకూడదని నిర్ణయించుకున్నారు మరియు దానిని నవీకరించడానికి డెవలపర్‌లకు టాస్క్ ఇచ్చారు.

మేము ఇప్పుడు మాస్టర్ బ్రాంచ్ యొక్క తాజా వెర్షన్ యొక్క స్థానిక కాపీని కలిగి ఉన్నాము. రీడ్‌మీ-ఇంప్రూవర్‌కి తిరిగి వెళ్లండి .

ఇప్పుడు మనం మాస్టర్ బ్రాంచ్ నుండి మాదికి మార్పులను తిరిగి పొందాలి. మేము దీన్ని చేస్తాము:

మీరు ప్రతిదీ సరిగ్గా చేసి, నాతో పాటు అనుసరించినట్లయితే, ఫలితం README ఫైల్‌లో వైరుధ్యాన్ని చూపుతుంది:

ఇక్కడ మనకు అర్థం చేసుకోవడానికి మరియు నానబెట్టడానికి చాలా సమాచారం ఉంది. వైరుధ్యాలు ఉన్న ఫైల్‌ల జాబితా (మా విషయంలో, ఒక ఫైల్) ఇక్కడ చూపబడింది. మేము మూడు ఎంపికల నుండి ఎంచుకోవచ్చు:

1. మీది అంగీకరించండి — readme-improver నుండి మార్పులను మాత్రమే అంగీకరించండి.
2. వారిది అంగీకరించండి - మాస్టర్ నుండి మార్పులను మాత్రమే అంగీకరించండి.
3. విలీనం చేయండి - మీరు ఏమి ఉంచాలనుకుంటున్నారో మరియు ఏమి విస్మరించాలో మీరే ఎంచుకోండి.

ఏమి మారుతుందో స్పష్టంగా లేదు. మార్పులు ఉంటే మాస్టర్ బ్రాంచ్, అవి తప్పనిసరిగా అక్కడ అవసరం, కాబట్టి మేము మా మార్పులను అంగీకరించలేము. దీని ప్రకారం, మేము విలీనాన్ని ఎంచుకుంటాము :

ఇక్కడ మూడు భాగాలు ఉన్నాయని మనం చూడవచ్చు:

1. ఇవి readme-improver నుండి వచ్చిన మార్పులు.
2. విలీన ఫలితం. ప్రస్తుతానికి, ఇది మార్పులకు ముందు ఉన్నది.
3. మాస్టర్ బ్రాంచ్ నుండి మార్పులు.

మేము ప్రతి ఒక్కరినీ సంతృప్తిపరిచే విలీన ఫలితాన్ని అందించాలి. మా మార్పులకు ముందు మార్చబడిన వాటిని సమీక్షిస్తే, వారు "పోల్నోస్ట్" అనే పదాన్ని తీసివేసినట్లు మేము గ్రహించాము. సరే, సమస్య లేదు! అంటే మేము దానిని విలీన ఫలితంలో కూడా తీసివేసి, ఆపై మా మార్పులను జోడిస్తాము. మేము విలీనం చేసిన ఫలితాన్ని సరిచేసిన తర్వాత, మేము వర్తించు క్లిక్ చేయవచ్చు .

అప్పుడు రీబేస్ విజయవంతమైందని తెలియజేసే నోటిఫికేషన్ పాప్ అప్ అవుతుంది:

అక్కడ! మేము IntelliJ IDEA ద్వారా మా మొదటి వైరుధ్యాన్ని పరిష్కరించాము.

రిమోట్ సర్వర్‌కు మార్పులను పుష్ చేయండి

తదుపరి దశ మార్పులను రిమోట్ సర్వర్‌కు నెట్టడం మరియు పుల్ అభ్యర్థనను సృష్టించడం. దీన్ని చేయడానికి, CTRL+SHIFT+K నొక్కండి . అప్పుడు మనకు లభిస్తుంది:

ఎడమ వైపున, రిమోట్ రిపోజిటరీకి నెట్టబడని కమిట్‌ల జాబితా ఉంటుంది. కుడి వైపున మార్చబడిన అన్ని ఫైల్‌లు ఉంటాయి. అంతే! పుష్ నొక్కండి మరియు మీరు ఆనందాన్ని అనుభవిస్తారు :)

పుష్ విజయవంతమైతే, దిగువ కుడి మూలలో మీరు ఇలాంటి నోటిఫికేషన్‌ను చూస్తారు:

బోనస్: పుల్ అభ్యర్థనను సృష్టించడం

GitHub రిపోజిటరీకి వెళ్దాం మరియు మనకు ఏమి కావాలో GitHubకి ఇప్పటికే తెలుసని మనం చూస్తాము:

సరిపోల్చండి & అభ్యర్థన లాగండి క్లిక్ చేయండి . ఆపై పుల్ అభ్యర్థనను సృష్టించు క్లిక్ చేయండి . మేము వైరుధ్యాలను ముందుగానే పరిష్కరించినందున, ఇప్పుడు పుల్ అభ్యర్థనను సృష్టించేటప్పుడు, మేము దానిని వెంటనే విలీనం చేయవచ్చు:

ప్రస్తుతానికి అంతే!