Git உடன் தொடங்குதல்: புதியவர்களுக்கான விரிவான வழிகாட்டி

ஒரு அறிமுகத்திற்கு பதிலாக

வணக்கம்! இன்று நாம் ஒரு பதிப்பு கட்டுப்பாட்டு அமைப்பு பற்றி பேச போகிறோம், அதாவது Git. உங்களுக்கு Git தெரியாவிட்டால்/புரியவில்லை என்றால், நிரலாக்கத்திற்கும் உங்களுக்கும் எந்த சம்பந்தமும் இல்லை. ஆனால் அழகு என்னவென்றால், தொடர்ச்சியாகப் பணிபுரிய அனைத்து Git கட்டளைகளையும் அம்சங்களையும் உங்கள் தலையில் வைத்திருக்க வேண்டியதில்லை. நடக்கும் அனைத்தையும் புரிந்துகொள்ள உதவும் கட்டளைகளின் தொகுப்பை நீங்கள் அறிந்து கொள்ள வேண்டும்.

ஜிட் அடிப்படைகள்

Git என்பது எங்கள் குறியீட்டிற்கான விநியோகிக்கப்பட்ட பதிப்பு கட்டுப்பாட்டு அமைப்பு. நமக்கு அது ஏன் தேவை? விநியோகிக்கப்பட்ட குழுக்கள் தங்கள் வேலையை நிர்வகிப்பதற்கு ஒருவித அமைப்பு தேவை. காலப்போக்கில் ஏற்படும் மாற்றங்களைக் கண்காணிப்பது அவசியம். அதாவது, எந்தெந்த கோப்புகள் எவ்வாறு மாறியுள்ளன என்பதை நாம் படிப்படியாகப் பார்க்க வேண்டும். ஒரு பணியின் சூழலில் என்ன மாற்றம் ஏற்பட்டது என்பதை நீங்கள் ஆராயும்போது இது மிகவும் முக்கியமானது, மாற்றங்களை மாற்றியமைப்பதை சாத்தியமாக்குகிறது.

Git ஐ நிறுவுகிறது

உங்கள் கணினியில் ஜாவாவை நிறுவுவோம்.

விண்டோஸில் நிறுவுதல்

வழக்கம் போல், நீங்கள் ஒரு exe கோப்பை பதிவிறக்கம் செய்து இயக்க வேண்டும். இங்கே எல்லாம் எளிது: முதல் Google இணைப்பைக் கிளிக் செய்து , நிறுவலைச் செய்யுங்கள், அவ்வளவுதான். இதைச் செய்ய, விண்டோஸ் வழங்கும் பாஷ் கன்சோலைப் பயன்படுத்துவோம். விண்டோஸில், நீங்கள் Git Bash ஐ இயக்க வேண்டும். தொடக்க மெனுவில் இது எப்படி இருக்கும் என்பது இங்கே: இப்போது இது நீங்கள் வேலை செய்யக்கூடிய கட்டளை வரியில் உள்ளது. Git ஐத் திறக்க ஒவ்வொரு முறையும் திட்டத்துடன் கூடிய கோப்புறைக்குச் செல்வதைத் தவிர்க்க, திட்டக் கோப்புறையில் கட்டளை வரியில் நமக்குத் தேவையான பாதையுடன் வலது சுட்டி பொத்தானைக் கொண்டு திறக்கலாம்:

லினக்ஸில் நிறுவுகிறது

வழக்கமாக Git லினக்ஸ் விநியோகங்களின் ஒரு பகுதியாகும் மற்றும் ஏற்கனவே நிறுவப்பட்டுள்ளது, ஏனெனில் இது முதலில் லினக்ஸ் கர்னல் மேம்பாட்டிற்காக எழுதப்பட்ட ஒரு கருவியாகும். ஆனால் அது இல்லாத சூழ்நிலைகள் உள்ளன. சரிபார்க்க, நீங்கள் ஒரு முனையத்தைத் திறந்து எழுத வேண்டும்: 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

ஒரு குறிப்பிட்ட திட்டத்திற்கான ஆசிரியரை நீங்கள் மாற்ற வேண்டும் என்றால், நீங்கள் "--global" ஐ அகற்றலாம். இது நமக்கு பின்வருவனவற்றை வழங்கும்:

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 உடன் பணிபுரிவது பற்றி பேசுகிறோம். நிச்சயமாக, நீங்கள் சில வகையான GUI- அடிப்படையிலான தீர்வைப் பயன்படுத்தலாம் (எடுத்துக்காட்டாக, IntelliJ IDEA), ஆனால் முதலில் நீங்கள் என்ன கட்டளைகள் செயல்படுத்தப்படுகின்றன மற்றும் அவை எதைக் குறிக்கின்றன என்பதைக் கண்டுபிடிக்க வேண்டும்.

உள்ளூர் களஞ்சியத்தில் Git உடன் பணிபுரிதல்

அடுத்து, நீங்கள் கட்டுரையைப் படிக்கும்போது நான் செய்த அனைத்து நடவடிக்கைகளையும் பின்பற்றிச் செய்யுமாறு பரிந்துரைக்கிறேன். இது பொருள் பற்றிய உங்கள் புரிதலையும் தேர்ச்சியையும் மேம்படுத்தும். சரி, பான் ஆப்பெடிட்! :) உள்ளூர் களஞ்சியத்தை உருவாக்க, நீங்கள் எழுத வேண்டும்:

git init

இது கன்சோலின் தற்போதைய கோப்பகத்தில் .git கோப்புறையை உருவாக்கும். .git கோப்புறை Git களஞ்சியத்தைப் பற்றிய அனைத்து தகவல்களையும் சேமிக்கிறது. அதை நீக்க வேண்டாம் ;) அடுத்து, திட்டத்தில் கோப்புகள் சேர்க்கப்படும், மேலும் அவை "கண்காணிக்கப்படாத" நிலை ஒதுக்கப்படும். உங்கள் பணியின் தற்போதைய நிலையைச் சரிபார்க்க, இதை எழுதவும்:

git status

நாங்கள் முதன்மைக் கிளையில் இருக்கிறோம், மற்றொரு கிளைக்கு மாறும் வரை இங்கேயே இருப்போம். எந்த கோப்புகள் மாறியுள்ளன, ஆனால் இன்னும் "நிலை" நிலைக்குச் சேர்க்கப்படவில்லை என்பதை இது காட்டுகிறது. அவற்றை "நிலை" நிலைக்குச் சேர்க்க, நீங்கள் "ஜிட் சேர்" என்று எழுத வேண்டும். எங்களிடம் சில விருப்பங்கள் உள்ளன, எடுத்துக்காட்டாக:

• git add -A — அனைத்து கோப்புகளையும் "நிலை" நிலைக்குச் சேர்க்கவும்
• git சேர். — இந்தக் கோப்புறையிலிருந்து அனைத்து கோப்புகளையும் அனைத்து துணை கோப்புறைகளையும் சேர்க்கவும். அடிப்படையில், இது முந்தையதைப் போன்றது
• git add <file name> — ஒரு குறிப்பிட்ட கோப்பை சேர்க்கிறது. சில வடிவங்களின்படி கோப்புகளைச் சேர்க்க இங்கே நீங்கள் வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, git add *.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"

இப்போது உண்மையின் தருணம்: எங்களிடம் ஒரு தொகுக்கப்பட்ட GitTest.class உள்ளது, அது "கண்காணிக்கப்படாதது", அதை நாங்கள் Git களஞ்சியத்தில் சேர்க்க விரும்பவில்லை. இப்போது நாம் .gitignore கோப்பின் விளைவுகளைப் பார்க்க வேண்டும்:

git status

சரியானது! .gitignore +1 :)

கிளைகள் மற்றும் பலவற்றுடன் பணிபுரிதல்

இயற்கையாகவே, ஒரு கிளையில் பணிபுரிவது தனிமையான டெவலப்பர்களுக்கு சிரமமாக இருக்கும், மேலும் ஒரு குழுவில் ஒன்றுக்கு மேற்பட்ட நபர்கள் இருக்கும்போது அது சாத்தியமற்றது. இதற்காகத்தான் எங்களிடம் கிளைகள் உள்ளன. நான் முன்பு கூறியது போல், ஒரு கிளை என்பது உறுதிப்பாட்டிற்கு நகரக்கூடிய ஒரு சுட்டி. இந்த பகுதியில், வெவ்வேறு கிளைகளில் வேலை செய்வதை ஆராய்வோம்: ஒரு கிளையிலிருந்து மற்றொரு கிளையில் மாற்றங்களை எவ்வாறு இணைப்பது, என்ன முரண்பாடுகள் ஏற்படலாம் மற்றும் பல. களஞ்சியத்தில் உள்ள அனைத்து கிளைகளின் பட்டியலைப் பார்க்கவும், நீங்கள் எதைப் பயன்படுத்துகிறீர்கள் என்பதைப் புரிந்து கொள்ளவும், நீங்கள் எழுத வேண்டும்:

git branch -a

எங்களிடம் ஒரே ஒரு மாஸ்டர் கிளை இருப்பதை நீங்கள் பார்க்கலாம். அதற்கு முன்னால் உள்ள நட்சத்திரக் குறியீடு நாம் அதில் இருப்பதைக் குறிக்கிறது. நாம் எந்தக் கிளையில் இருக்கிறோம் என்பதைக் கண்டறிய "git status" கட்டளையையும் நீங்கள் பயன்படுத்தலாம். பின்னர் கிளைகளை உருவாக்குவதற்குப் பல விருப்பங்கள் உள்ளன (இன்னும் அதிகமாக இருக்கலாம் - இவைதான் நான் பயன்படுத்துகிறேன்):

• நாம் இருக்கும் கிளையின் அடிப்படையில் ஒரு புதிய கிளையை உருவாக்கவும் (99% வழக்குகள்)
• ஒரு குறிப்பிட்ட உறுதியின் அடிப்படையில் ஒரு கிளையை உருவாக்கவும் (1% வழக்குகள்)

ஒரு குறிப்பிட்ட உறுதியின் அடிப்படையில் ஒரு கிளையை உருவாக்குவோம்

உறுதிமொழியின் தனித்துவமான அடையாளங்காட்டியை நாங்கள் நம்புவோம். அதைக் கண்டுபிடிக்க, நாங்கள் எழுதுகிறோம்:

git log

"ஹலோ வேர்ல்ட் சேர்த்தது..." என்ற கருத்துடன் உறுதிமொழியை நான் ஹைலைட் செய்துள்ளேன், இதன் தனித்துவமான அடையாளங்காட்டி 6c44e53d06228f888f2f454d3cb8c1c976dd73f8 ஆகும். இந்த உறுதிப்பாட்டிலிருந்து தொடங்கும் ஒரு "வளர்ச்சி" கிளையை உருவாக்க விரும்புகிறேன். இதைச் செய்ய, நான் எழுதுகிறேன்:

git checkout -b development 6c44e53d06228f888f2f454d3cb8c1c976dd73f8

முதன்மைக் கிளையிலிருந்து முதல் இரண்டு கமிட்களை மட்டுமே கொண்டு ஒரு கிளை உருவாக்கப்பட்டது. இதைச் சரிபார்க்க, நாங்கள் முதலில் வேறு கிளைக்கு மாறுவதை உறுதிசெய்து, அங்குள்ள கமிட்களின் எண்ணிக்கையைப் பார்க்கிறோம்:

git status
git log

எதிர்பார்த்தபடி, எங்களிடம் இரண்டு உறுதிப்பாடுகள் உள்ளன. மூலம், இங்கே ஒரு சுவாரஸ்யமான விஷயம்: இந்தக் கிளையில் இதுவரை .gitignore கோப்பு இல்லை, எனவே எங்கள் தொகுக்கப்பட்ட கோப்பு (GitTest.class) இப்போது "கண்காணிக்கப்படாத" நிலையுடன் முன்னிலைப்படுத்தப்பட்டுள்ளது. இப்போது இதை எழுதுவதன் மூலம் எங்கள் கிளைகளை மீண்டும் மதிப்பாய்வு செய்யலாம்:

git branch -a

இரண்டு கிளைகள் இருப்பதை நீங்கள் காணலாம்: "மாஸ்டர்" மற்றும் "வளர்ச்சி". நாங்கள் தற்போது வளர்ச்சியில் இருக்கிறோம்.

தற்போதுள்ள கிளையின் அடிப்படையில் ஒரு கிளையை உருவாக்குவோம்

ஒரு கிளையை உருவாக்குவதற்கான இரண்டாவது வழி, அதை மற்றொன்றிலிருந்து உருவாக்குவது. மாஸ்டர் கிளையின் அடிப்படையில் ஒரு கிளையை உருவாக்க விரும்புகிறேன். முதலில், நான் அதற்கு மாற வேண்டும், அடுத்த படி புதிய ஒன்றை உருவாக்க வேண்டும். பார்ப்போம்:

• git Checkout master — முதன்மை கிளைக்கு மாறவும்
• git நிலை - நாங்கள் உண்மையில் முதன்மைக் கிளையில் இருக்கிறோம் என்பதைச் சரிபார்க்கவும்

நாங்கள் முதன்மைக் கிளைக்கு மாறியதையும், .gitignore கோப்பு நடைமுறையில் இருப்பதையும், தொகுக்கப்பட்ட கிளாஸ் இனி "ட்ராக் செய்யப்படாதது" என முன்னிலைப்படுத்தப்படுவதையும் இங்கே காணலாம். இப்போது நாம் முதன்மை கிளையின் அடிப்படையில் ஒரு புதிய கிளையை உருவாக்குகிறோம்:

git checkout -b feature/update-txt-files

இந்தக் கிளையும் "மாஸ்டர்" என்பதும் ஒன்றா என்பது உங்களுக்குத் தெரியாவிட்டால், "git log"ஐ இயக்கி, அனைத்து கமிட்களையும் பார்த்து எளிதாகச் சரிபார்க்கலாம். அவற்றில் நான்கு இருக்க வேண்டும்.

சச்சரவுக்கான தீர்வு

மோதல் என்றால் என்ன என்பதை ஆராய்வதற்கு முன், ஒரு கிளையை மற்றொரு கிளையுடன் இணைப்பது பற்றி பேச வேண்டும். இந்த படம் ஒரு கிளையை மற்றொன்றில் இணைக்கும் செயல்முறையை சித்தரிக்கிறது: இங்கே, எங்களுக்கு ஒரு முக்கிய கிளை உள்ளது. ஒரு கட்டத்தில், ஒரு இரண்டாம் கிளை பிரதான கிளையிலிருந்து உருவாக்கப்பட்டு பின்னர் மாற்றியமைக்கப்படுகிறது. வேலை முடிந்ததும், ஒரு கிளையை மற்றொன்றில் இணைக்க வேண்டும். பல்வேறு அம்சங்களை நான் விவரிக்க மாட்டேன்: இந்த கட்டுரையில், நான் ஒரு பொதுவான புரிதலை மட்டுமே தெரிவிக்க விரும்புகிறேன். உங்களுக்கு விவரங்கள் தேவைப்பட்டால், அவற்றை நீங்களே பார்க்கலாம். எங்கள் எடுத்துக்காட்டில், நாங்கள் அம்சம்/புதுப்பிப்பு-txt-files கிளையை உருவாக்கினோம். கிளையின் பெயரால் குறிப்பிடப்பட்டுள்ளபடி, நாங்கள் உரையைப் புதுப்பிக்கிறோம். இப்போது இந்த வேலைக்கு ஒரு புதிய உறுதிமொழியை உருவாக்க வேண்டும்:

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 commit

அதைப் போலவே, நாங்கள் அதைச் செய்தோம் - கன்சோலில் உள்ள மோதலைத் தீர்த்தோம். நிச்சயமாக, ஒருங்கிணைந்த வளர்ச்சி சூழல்களில் இதை சற்று எளிதாக செய்ய முடியும். எடுத்துக்காட்டாக, IntelliJ IDEA இல், தேவையான அனைத்து செயல்களையும் நீங்கள் செய்யக்கூடிய வகையில் அனைத்தும் சிறப்பாக அமைக்கப்பட்டுள்ளன. ஆனால் IDE கள் "ஹூட்டின் கீழ்" நிறைய விஷயங்களைச் செய்கின்றன, மேலும் அங்கு என்ன நடக்கிறது என்பது நமக்குப் புரியாது. மற்றும் புரிதல் இல்லாதபோது, ​​​​சிக்கல்கள் ஏற்படலாம்.

தொலை களஞ்சியங்களுடன் பணிபுரிதல்

ரிமோட் களஞ்சியத்துடன் பணிபுரியத் தேவையான இன்னும் சில கட்டளைகளைக் கண்டுபிடிப்பதே கடைசிப் படியாகும். நான் சொன்னது போல், ரிமோட் ரெபோசிட்டரி என்பது களஞ்சியம் சேமிக்கப்படும் சில இடமாகும், அதில் இருந்து நீங்கள் அதை குளோன் செய்யலாம். என்ன வகையான ரிமோட் களஞ்சியங்கள் உள்ளன? எடுத்துக்காட்டுகள்:

• கிட்ஹப் என்பது களஞ்சியங்கள் மற்றும் கூட்டு மேம்பாட்டிற்கான மிகப்பெரிய சேமிப்பக தளமாகும். நான் ஏற்கனவே முந்தைய கட்டுரைகளில் விவரித்தேன். GitHub
  இல் என்னைப் பின்தொடரவும் . நான் வேலைக்காகப் படிக்கும் பகுதிகளில் அடிக்கடி என் வேலையைக் காட்டுவேன்.

• கிட்லேப் என்பது டெவொப்ஸ் வாழ்க்கைச் சுழற்சிக்கான இணைய அடிப்படையிலான கருவியாகும் . இது அதன் சொந்த விக்கி, பிழை கண்காணிப்பு அமைப்பு , CI/CD பைப்லைன் மற்றும் பிற செயல்பாடுகளுடன் குறியீடு களஞ்சியங்களை நிர்வகிப்பதற்கான Git- அடிப்படையிலான அமைப்பாகும். மைக்ரோசாப்ட் கிட்ஹப்பை வாங்கிய செய்திக்குப் பிறகு, சில டெவலப்பர்கள் தங்கள் திட்டங்களை கிட்லாப்பில் நகலெடுத்தனர்.
  

• BitBucket என்பது Mercurial மற்றும் 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 ஆவணங்கள் . நான் அதை ஒரு குறிப்பு என பரிந்துரைக்கிறேன்.