Gitతో ప్రారంభించడం: కొత్తవారి కోసం ఒక సమగ్ర గైడ్

పరిచయానికి బదులుగా

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

Git బేసిక్స్

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

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

మీ కంప్యూటర్‌లో జావాను ఇన్‌స్టాల్ చేద్దాం.

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

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

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

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

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

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

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

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

git config --global user.name "Ivan Ivanov"
git config --global user.email ivan.ivanov@gmail.com

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

git config user.name "Ivan Ivanov"
git config user.email ivan.ivanov@gmail.com

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

టాపిక్‌లోకి ప్రవేశించడానికి, మేము మీకు కొన్ని కొత్త పదాలు మరియు చర్యలను పరిచయం చేయాలి...

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

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

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

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

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

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

ఇవి మా కోడ్‌ను కలిగి ఉన్న ఫైల్‌లకు వర్తించే స్థితిగతులు:

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

ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది:

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

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

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

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

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

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

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

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

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

తర్వాత, మీరు కథనాన్ని చదివేటప్పుడు నేను చేసిన అన్ని దశలను అనుసరించి, పూర్తి చేయాలని నేను సూచిస్తున్నాను. ఇది పదార్థంపై మీ అవగాహన మరియు నైపుణ్యాన్ని మెరుగుపరుస్తుంది. బాగా, బాన్ అపెటిట్! :) స్థానిక రిపోజిటరీని సృష్టించడానికి, మీరు వ్రాయాలి:

git init

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

git status

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

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

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

git add *.txt

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

git status

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

git commit -m "all txt files were added to the project"

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

git log

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

git status

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

git status

ఇక్కడ మీరు "ట్రాక్ చేయని" మరియు "సవరించిన" స్థితిగతుల మధ్య వ్యత్యాసాన్ని స్పష్టంగా చూడవచ్చు. GitTest.java "ట్రాక్ చేయబడలేదు", అయితే test_resource.txt "మార్చబడింది". ఇప్పుడు మేము సవరించిన స్థితిలో ఫైల్‌లను కలిగి ఉన్నాము, మేము వాటికి చేసిన మార్పులను పరిశీలించవచ్చు. కింది ఆదేశాన్ని ఉపయోగించి ఇది చేయవచ్చు:

git diff

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

git add test_resource.txt
git commit -m "added hello word! to test_resource.txt"

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

git log

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

git add GitTest.java
git commit -m "added GitTest.java"
git status

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

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

```
*.class
target/
*.iml
.idea/
```

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

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

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

git status

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

git add .gitignore
git commit -m "added .gitignore file"

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

git status

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

శాఖలతో పని చేయడం మొదలైనవి

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

git branch -a

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

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

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

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

git log

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

git checkout -b development 6c44e53d06228f888f2f454d3cb8c1c976dd73f8

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

git status
git log

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

git branch -a

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

ప్రస్తుత శాఖ ఆధారంగా ఒక శాఖను సృష్టిద్దాం

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

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

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

git checkout -b feature/update-txt-files

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

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

సంఘర్షణ అంటే ఏమిటో అన్వేషించే ముందు, ఒక శాఖను మరొక శాఖలో విలీనం చేయడం గురించి మాట్లాడాలి. ఈ చిత్రం ఒక శాఖను మరొక శాఖలో విలీనం చేసే ప్రక్రియను వర్ణిస్తుంది: ఇక్కడ, మనకు ప్రధాన శాఖ ఉంది. ఏదో ఒక సమయంలో, ప్రధాన శాఖ నుండి ద్వితీయ శాఖ సృష్టించబడుతుంది మరియు తరువాత సవరించబడుతుంది. పని పూర్తయిన తర్వాత, మేము ఒక శాఖను మరొకదానిలో విలీనం చేయాలి. నేను వివిధ లక్షణాలను వివరించను: ఈ వ్యాసంలో, నేను సాధారణ అవగాహనను మాత్రమే తెలియజేయాలనుకుంటున్నాను. మీకు వివరాలు అవసరమైతే, మీరు వాటిని మీరే చూసుకోవచ్చు. మా ఉదాహరణలో, మేము ఫీచర్/అప్‌డేట్-txt-ఫైల్స్ శాఖను సృష్టించాము. శాఖ పేరు సూచించినట్లుగా, మేము వచనాన్ని నవీకరిస్తున్నాము. ఇప్పుడు మనం ఈ పని కోసం కొత్త నిబద్ధతను సృష్టించాలి:

git add *.txt 
git commit -m "updated txt files"
git log

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

git checkout master
git merge feature/update-txt-files
git log

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

git branch -D feature/update-txt-files

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

git checkout -b feature/add-header
... we make changes to the file

git add *.txt
git commit -m "added header to txt"

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

git checkout master
… we updated test_resource.txt

git add test_resource.txt
git commit -m "added master header to txt"

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

git merge feature/add-header

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

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

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

git status

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

git add *.txt

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

git commit

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

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

రిమోట్ రిపోజిటరీతో పని చేయడానికి అవసరమైన మరికొన్ని ఆదేశాలను గుర్తించడం చివరి దశ. నేను చెప్పినట్లుగా, రిమోట్ రిపోజిటరీ అనేది రిపోజిటరీ నిల్వ చేయబడిన ప్రదేశం మరియు దాని నుండి మీరు దానిని క్లోన్ చేయవచ్చు. ఎలాంటి రిమోట్ రిపోజిటరీలు ఉన్నాయి? ఉదాహరణలు:

• GitHub అనేది రిపోజిటరీలు మరియు సహకార అభివృద్ధి కోసం అతిపెద్ద నిల్వ వేదిక. నేను ఇప్పటికే మునుపటి వ్యాసాలలో వివరించాను. GitHub
  లో నన్ను అనుసరించండి . నేను పని కోసం చదువుతున్న ప్రాంతాలలో తరచుగా నా పనిని ప్రదర్శిస్తాను.

• GitLab అనేది ఓపెన్ సోర్స్‌తో DevOps జీవితచక్రం కోసం వెబ్ ఆధారిత సాధనం . ఇది దాని స్వంత వికీ, బగ్ ట్రాకింగ్ సిస్టమ్ , CI/CD పైప్‌లైన్ మరియు ఇతర ఫంక్షన్‌లతో కోడ్ రిపోజిటరీలను నిర్వహించడానికి Git- ఆధారిత సిస్టమ్. మైక్రోసాఫ్ట్ గిట్‌హబ్‌ను కొనుగోలు చేసిన వార్త తర్వాత, కొంతమంది డెవలపర్లు తమ ప్రాజెక్ట్‌లను గిట్‌ల్యాబ్‌లో నకిలీ చేశారు.
  

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

• మరియు అందువలన న…

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

git clone https://github.com/romankh3/git-demo

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

git pull

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

git add test_resource.txt
git commit -m "prepared txt for pushing"

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

git push

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

ఉపయోగకరమైన లింక్

• అధికారిక Git డాక్యుమెంటేషన్ . నేను దానిని సూచనగా సిఫార్సు చేస్తున్నాను.