1. ஆரம்பநிலைக்கான Gitக்கான விரிவான வழிகாட்டி

இன்று நாம் ஒரு பதிப்பு கட்டுப்பாட்டு அமைப்பு பற்றி பேச போகிறோம், அதாவது Git.

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

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

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

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

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

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

நீங்கள் Git ஐப் பயன்படுத்தினால் இதுபோன்ற பிரச்சனைகள் இருக்காது.

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

உங்கள் கணினியில் ஜாவாவை நிறுவுவோம் இந்த செயல்முறை வெவ்வேறு இயக்க முறைமைகளுக்கு சற்று மாறுபடும்.

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

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

விண்டோஸில், நீங்கள் Git Bash ஐ இயக்க வேண்டும். தொடக்க மெனுவில் இது எப்படி இருக்கிறது என்பது இங்கே:

இப்போது இது நீங்கள் வேலை செய்யக்கூடிய கட்டளை வரியில் உள்ளது.

Git ஐத் திறக்க ஒவ்வொரு முறையும் திட்டத்துடன் கோப்புறைக்குச் செல்வதைத் தவிர்க்க, திட்டக் கோப்புறையில் கட்டளை வரியில் நமக்குத் தேவையான பாதையுடன் வலது சுட்டி பொத்தானைக் கொண்டு திறக்கலாம்:

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

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

ஒரு முனையத்தைத் திறந்து நிறுவவும். உபுண்டுவிற்கு, நீங்கள் எழுத வேண்டும்: sudo apt-get install git. அவ்வளவுதான்: இப்போது நீங்கள் எந்த முனையத்திலும் Git ஐப் பயன்படுத்தலாம்.

MacOS இல் நிறுவுகிறது

இங்கேயும், நீங்கள் முதலில் Git ஏற்கனவே உள்ளதா என்பதைச் சரிபார்க்க வேண்டும் (மேலே காண்க, லினக்ஸில் உள்ளதைப் போன்றது).

உங்களிடம் அது இல்லையென்றால், சமீபத்திய பதிப்பைப் பதிவிறக்குவதே அதைப் பெறுவதற்கான எளிதான வழி . Xcode நிறுவப்பட்டிருந்தால், Git நிச்சயமாக தானாகவே நிறுவப்படும்.

Git அமைப்புகள்

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

பின்வரும் கட்டளைகளை இயக்குவதன் மூலம் உங்கள் எல்லா திட்டங்களுக்கும் பயனர்பெயர் மற்றும் கடவுச்சொல்லை அமைக்கவும்:

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

கொஞ்சம் கோட்பாடு

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

என்ன வார்த்தைகள் மற்றும் செயல்கள்?

• git களஞ்சியம்
• உறுதி
• கிளை
• ஒன்றிணைக்க
• மோதல்கள்
• இழுக்க
• தள்ளு
• சில கோப்புகளை எவ்வாறு புறக்கணிப்பது (.gitignore)

மற்றும் பல.

Git இல் நிலைகள்

Git பல சிலைகளைக் கொண்டுள்ளது, அவை புரிந்து கொள்ளப்பட வேண்டும் மற்றும் நினைவில் கொள்ள வேண்டும்:

• கண்காணிக்கப்படவில்லை
• மாற்றியமைக்கப்பட்டது
• அரங்கேற்றப்பட்டது
• உறுதி

இதை எப்படி புரிந்து கொள்ள வேண்டும்?

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

• உருவாக்கப்பட்ட ஆனால் இன்னும் களஞ்சியத்தில் சேர்க்கப்படாத ஒரு கோப்பு "கண்காணிக்கப்படாத" நிலையைக் கொண்டுள்ளது.
• Git களஞ்சியத்தில் ஏற்கனவே சேர்க்கப்பட்ட கோப்புகளில் நாம் மாற்றங்களைச் செய்தால், அவற்றின் நிலை "மாற்றியமைக்கப்படும்".
• நாங்கள் மாற்றிய கோப்புகளில், நமக்குத் தேவையானவற்றைத் தேர்ந்தெடுக்கிறோம் (எடுத்துக்காட்டாக, தொகுக்கப்பட்ட வகுப்புகள் எங்களுக்குத் தேவையில்லை), மேலும் இந்த வகுப்புகள் "நிலை" நிலைக்கு மாற்றப்படுகின்றன.
• ஸ்டேஜ் செய்யப்பட்ட நிலையில் தயாரிக்கப்பட்ட கோப்புகளிலிருந்து ஒரு உறுதி உருவாக்கப்பட்டு Git களஞ்சியத்திற்குச் செல்கிறது. அதன் பிறகு, "நிலை" நிலை கொண்ட கோப்புகள் எதுவும் இல்லை. ஆனால் "மாற்றியமைக்கப்பட்ட" கோப்புகள் இன்னும் இருக்கலாம்.

இது எப்படி இருக்கிறது:

உறுதி என்றால் என்ன?

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

குறிப்பாக, ஒரு முதல் அர்ப்பணிப்பு உள்ளது. இரண்டாவது கமிட் உருவாக்கப்படும் போது, ​​அது (இரண்டாவது) முதலாவதாக வருவதை அறியும். இந்த முறையில், தகவல்களைக் கண்காணிக்க முடியும்.

ஒரு கமிட் அதன் சொந்த தகவல்களையும் கொண்டுள்ளது, மெட்டாடேட்டா என அழைக்கப்படும்:

• உறுதியின் தனித்துவமான அடையாளங்காட்டி, அதைக் கண்டுபிடிக்கப் பயன்படுத்தலாம்
• அதை உருவாக்கிய கமிட்டியின் ஆசிரியரின் பெயர்
• உறுதி உருவாக்கப்பட்ட தேதி
• உறுதிமொழியின் போது என்ன செய்யப்பட்டது என்பதை விவரிக்கும் கருத்து

இது எப்படி இருக்கிறது என்பது இங்கே:

கிளை என்றால் என்ன?

ஒரு கிளை என்பது சில உறுதிமொழிகளுக்கு ஒரு சுட்டி. ஒரு கமிட் அதற்கு முந்திய கமிட் என்பதை அறிந்திருப்பதால், ஒரு கிளை ஒரு உறுதிப்பாட்டை சுட்டிக்காட்டும்போது, ​​அந்த முந்தைய கமிட்கள் அனைத்தும் அதற்கும் பொருந்தும்.

அதன்படி, ஒரே உறுதிப்பாட்டைச் சுட்டிக்காட்டி நீங்கள் எத்தனை கிளைகளை வேண்டுமானாலும் வைத்திருக்கலாம் என்று நாங்கள் கூறலாம்.

கிளைகளில் வேலை நடக்கிறது, எனவே ஒரு புதிய உறுதி உருவாக்கப்படும் போது, ​​கிளை அதன் சுட்டியை மிக சமீபத்திய உறுதிக்கு நகர்த்துகிறது.

Git உடன் தொடங்குதல்

நீங்கள் ஒரு உள்ளூர் களஞ்சியத்துடன் தனியாகவும், தொலைநிலையுடனும் வேலை செய்யலாம்.

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

ரிமோட் களஞ்சியத்தைப் பற்றி நாங்கள் பேசுகிறோம் என்றால், எல்லா தகவல்களும் தொலை சேவையகத்தில் எங்காவது சேமிக்கப்படும்: திட்டத்தின் நகல் மட்டுமே உள்நாட்டில் சேமிக்கப்படும். உங்கள் உள்ளூர் நகலில் செய்யப்பட்ட மாற்றங்களை ரிமோட் களஞ்சியத்திற்கு (ஜிட் புஷ்) தள்ளலாம்.

இங்கே மற்றும் கீழே எங்கள் விவாதத்தில், கன்சோலில் Git உடன் பணிபுரிவது பற்றி பேசுகிறோம். நிச்சயமாக, நீங்கள் சில வகையான GUI- அடிப்படையிலான தீர்வைப் பயன்படுத்தலாம் (எடுத்துக்காட்டாக, IntelliJ IDEA), ஆனால் முதலில் நீங்கள் என்ன கட்டளைகள் செயல்படுத்தப்படுகின்றன மற்றும் அவை எதைக் குறிக்கின்றன என்பதைக் கண்டுபிடிக்க வேண்டும்.

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

உள்ளூர் களஞ்சியத்தை உருவாக்க, நீங்கள் எழுத வேண்டும்:

இது கன்சோலின் தற்போதைய கோப்பகத்தில் மறைக்கப்பட்ட .git கோப்புறையை உருவாக்கும்.

.git கோப்புறை Git களஞ்சியத்தைப் பற்றிய அனைத்து தகவல்களையும் சேமிக்கிறது. அதை நீக்காதே ;)

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

நாங்கள் முதன்மைக் கிளையில் இருக்கிறோம், மற்றொரு கிளைக்கு மாறும் வரை இங்கேயே இருப்போம்.

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

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

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

இப்போது நாம் .gitignore கோப்பின் விளைவுகளைப் பார்க்க வேண்டும்:

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

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

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

ஒரு கிளை என்பது உறுதிப்பாட்டிற்கு நகரக்கூடிய ஒரு சுட்டி.

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

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

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

கிளைகளை உருவாக்குவதற்கு பல விருப்பங்கள் உள்ளன (மேலும் இருக்கலாம் - இவைதான் நான் பயன்படுத்துகிறேன்):

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

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

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

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

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

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

இப்போது இதை எழுதுவதன் மூலம் எங்கள் கிளைகளை மீண்டும் மதிப்பாய்வு செய்யலாம்:

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

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

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

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

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

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

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

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

மோதல் என்றால் என்ன என்பதை ஆராய்வதற்கு முன், ஒரு கிளையை மற்றொரு கிளையுடன் இணைப்பது பற்றி பேச வேண்டும்.

இந்த படம் ஒரு கிளையை மற்றொரு கிளையுடன் இணைக்கும் செயல்முறையை சித்தரிக்கிறது:

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

எங்கள் எடுத்துக்காட்டில், நாங்கள் அம்சம்/புதுப்பிப்பு-txt-files கிளையை உருவாக்கினோம். கிளையின் பெயரால் குறிப்பிடப்பட்டுள்ளபடி, நாங்கள் உரையைப் புதுப்பிக்கிறோம்.

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

இப்போது, ​​அம்சம்/புதுப்பிப்பு-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 நமக்குச் சொல்கிறது. இது இந்த பகுதியை வெவ்வேறு கிளைகளிலிருந்து இரண்டு பகுதிகளாகப் பிரித்து, ஒன்றிணைப்பு மோதலை நாமே தீர்க்க நம்மை அழைக்கிறது.

நியாயமான போதும். "தலைப்பு" என்ற வார்த்தையை மட்டும் விட்டுவிட்டு எல்லாவற்றையும் அகற்ற நான் தைரியமாக முடிவு செய்கிறேன்:

மாற்றங்களின் நிலையைப் பார்ப்போம். விளக்கம் சற்று வித்தியாசமாக இருக்கும். "மாற்றியமைக்கப்பட்ட" நிலைக்குப் பதிலாக, நாங்கள் "இணைக்கப்படாதது". எனவே ஐந்தாவது நிலையைக் குறிப்பிட்டிருக்க முடியுமா? இது தேவையில்லை என்று நினைக்கிறேன். பார்ப்போம்:

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

விளக்கம் "ஜிட் கமிட்" என்று மட்டும் எழுதுவதை நீங்கள் கவனிக்கலாம். அதை எழுத முயற்சிப்போம்:

அதைப் போலவே, நாங்கள் அதைச் செய்தோம் - கன்சோலில் உள்ள மோதலைத் தீர்த்தோம்.

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

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

ரிமோட் களஞ்சியத்துடன் பணிபுரிய இன்னும் சில கட்டளைகளைக் கண்டுபிடிப்பதே கடைசிப் படியாகும்.

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

என்ன வகையான ரிமோட் களஞ்சியங்கள் உள்ளன? எடுத்துக்காட்டுகள்:

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

தொலைநிலைக் களஞ்சியத்துடன் பணிபுரியும் போது, ​​முதலில் செய்ய வேண்டியது, திட்டத்தை உங்கள் உள்ளூர் களஞ்சியத்திற்கு குளோன் செய்வதாகும்.

இதற்காக, நாங்கள் உள்நாட்டில் உருவாக்கிய திட்டத்தை ஏற்றுமதி செய்தோம், இப்போது அனைவரும் அதை எழுதுவதன் மூலம் தங்களுக்கு குளோன் செய்யலாம்:

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

எங்கள் விஷயத்தில், ரிமோட் ரிபோசிட்டரியில் தற்போது எதுவும் மாறவில்லை, எனவே பதில்: ஏற்கனவே புதுப்பித்த நிலையில் உள்ளது.

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

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

இப்போது எங்களுக்கு மிகவும் பொதுவான ஒன்று - இந்த வேலைக்கான உறுதிப்பாட்டை நாங்கள் உருவாக்குகிறோம்:

இதை ரிமோட் களஞ்சியத்திற்கு தள்ளுவதற்கான கட்டளை:

இப்போதைக்கு அவ்வளவுதான்!

2. IntelliJ IDEA இல் Git உடன் எவ்வாறு வேலை செய்வது

இந்த பகுதியில், IntelliJ IDEA இல் Git உடன் எவ்வாறு வேலை செய்வது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள்.

தேவையான உள்ளீடுகள்:

1. முந்தைய பகுதியைப் படிக்கவும், பின்பற்றவும், புரிந்து கொள்ளவும். இது அனைத்தும் அமைக்கப்பட்டு செல்ல தயாராக இருப்பதை உறுதிசெய்ய உதவும்.
2. IntelliJ IDEA ஐ நிறுவவும். இங்கே எல்லாம் ஒழுங்காக இருக்க வேண்டும் :)
3. முழுமையான தேர்ச்சியை அடைய ஒரு மணி நேரம் ஒதுக்குங்கள்.

Git பற்றிய கட்டுரைக்கு நான் பயன்படுத்திய டெமோ திட்டத்தில் வேலை செய்வோம் .

திட்டத்தை உள்நாட்டில் குளோன் செய்யவும்

இங்கே இரண்டு விருப்பங்கள் உள்ளன:

1. உங்களிடம் ஏற்கனவே கிட்ஹப் கணக்கு இருந்தால், பின்னர் ஏதாவது ஒன்றைத் தள்ள விரும்பினால், திட்டத்தைப் பிரித்து உங்கள் சொந்த நகலை குளோன் செய்வது நல்லது. ஃபோர்க்கிங் பணிப்பாய்வுக்கான உதாரணம் என்ற தலைப்பின் கீழ் மற்றொரு கட்டுரையில் ஒரு முட்கரண்டியை எவ்வாறு உருவாக்குவது என்பது பற்றி நீங்கள் படிக்கலாம் .
2. களஞ்சியத்தை குளோன் செய்து, முழு விஷயத்தையும் சேவையகத்திற்குத் தள்ளும் திறன் இல்லாமல் எல்லாவற்றையும் உள்நாட்டில் செய்யுங்கள்.

GitHub இலிருந்து ஒரு திட்டத்தை குளோன் செய்ய, நீங்கள் திட்ட இணைப்பை நகலெடுத்து IntelliJ IDEA க்கு அனுப்ப வேண்டும்:

1. திட்ட முகவரியை நகலெடுக்கவும்:

2. IntelliJ IDEA ஐத் திறந்து "பதிப்புக் கட்டுப்பாட்டிலிருந்து பெறு" என்பதைத் தேர்ந்தெடுக்கவும்:

3. திட்ட முகவரியை நகலெடுத்து ஒட்டவும்:

4. IntelliJ IDEA திட்டத்தை உருவாக்கும்படி கேட்கப்படுவீர்கள். சலுகையை ஏற்கவும்:

5. உருவாக்க அமைப்பு இல்லாததால், "தற்போதுள்ள மூலங்களிலிருந்து திட்டத்தை உருவாக்கு" என்பதைத் தேர்ந்தெடுக்கிறோம்:

6. அடுத்து நீங்கள் இந்த அழகான திரையைப் பார்ப்பீர்கள்:

இப்போது நாங்கள் குளோனிங்கைக் கண்டுபிடித்தோம், நீங்கள் சுற்றிப் பார்க்கலாம்.

Git UI ஆக IntelliJ IDEA இல் முதல் பார்வை

குளோன் செய்யப்பட்ட திட்டத்தைக் கூர்ந்து கவனியுங்கள்: பதிப்புக் கட்டுப்பாட்டு அமைப்பைப் பற்றி நீங்கள் ஏற்கனவே நிறைய தகவல்களைப் பெறலாம்.

முதலில், கீழ் இடது மூலையில் பதிப்பு கட்டுப்பாட்டு பலகம் உள்ளது. இங்கே நீங்கள் அனைத்து உள்ளூர் மாற்றங்களையும் காணலாம் மற்றும் உறுதிகளின் பட்டியலைப் பெறலாம் ("git log" க்கு ஒப்பானது).

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

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

இந்த உறுதிப்பாட்டின் போது மாற்றப்பட்ட கோப்பில் இருமுறை கிளிக் செய்தால், முரண்பாடு எவ்வாறு தீர்க்கப்பட்டது என்பதைப் பார்ப்போம்:

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

ஒரு திட்டத்தில் பல கிளைகள், கமிட்டிகள் மற்றும் பயனர்கள் இருக்கும்போது, ​​கிளை, பயனர் மற்றும் தேதி ஆகியவற்றின் அடிப்படையில் நீங்கள் தனித்தனியாக தேட வேண்டும்:

தொடங்குவதற்கு முன், நாம் எந்தக் கிளையில் இருக்கிறோம் என்பதைப் புரிந்துகொள்வதும் பயனுள்ளது.

கீழ் வலது மூலையில், "Git: master" என்று பெயரிடப்பட்ட ஒரு பொத்தான் உள்ளது. "Git:" என்பது தற்போதைய கிளையாகும். நீங்கள் பொத்தானைக் கிளிக் செய்தால், நீங்கள் பல பயனுள்ள விஷயங்களைச் செய்யலாம்: மற்றொரு கிளைக்கு மாறவும், புதிய ஒன்றை உருவாக்கவும், ஏற்கனவே உள்ள ஒன்றை மறுபெயரிடவும் மற்றும் பல.

ஒரு களஞ்சியத்துடன் பணிபுரிதல்

பயனுள்ள ஹாட்ஸ்கிகள்

எதிர்கால வேலைக்கு, நீங்கள் சில பயனுள்ள ஹாட்ஸ்கிகளை நினைவில் கொள்ள வேண்டும்:

1. CTRL+T — தொலைநிலைக் களஞ்சியத்திலிருந்து (ஜிட் புல்) சமீபத்திய மாற்றங்களைப் பெறுங்கள்.
2. CTRL+K — ஒரு உறுதியை உருவாக்கவும் / தற்போதைய அனைத்து மாற்றங்களையும் பார்க்கவும். இதில் கண்காணிக்கப்படாத மற்றும் மாற்றியமைக்கப்பட்ட கோப்புகள் (ஜிட் கமிட்) அடங்கும்.
3. CTRL+SHIFT+K — இது ரிமோட் களஞ்சியத்தில் மாற்றங்களை அழுத்துவதற்கான கட்டளை. உள்நாட்டில் உருவாக்கப்பட்ட மற்றும் தொலைநிலைக் களஞ்சியத்தில் இல்லாத அனைத்து கமிட்களும் தள்ளப்படும் (ஜிட் புஷ்).
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-improver பக்கத்துக்குத் திரும்பு .

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

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

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

1. உன்னுடையதை ஏற்றுக்கொள் — readme-improver இலிருந்து மாற்றங்களை மட்டும் ஏற்றுக்கொள்.
2. அவற்றை ஏற்றுக்கொள் - எஜமானரிடமிருந்து மாற்றங்களை மட்டும் ஏற்றுக்கொள்.
3. ஒன்றிணைக்கவும் - நீங்கள் எதை வைத்திருக்க விரும்புகிறீர்கள் மற்றும் எதை நிராகரிக்க வேண்டும் என்பதை நீங்களே தேர்வு செய்யவும்.

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

இங்கு மூன்று பகுதிகள் இருப்பதைக் காணலாம்:

1. இவை readme-improver இல் இருந்து வந்த மாற்றங்கள்.
2. இணைக்கப்பட்ட முடிவு. இப்போதைக்கு, மாற்றங்களுக்கு முன் இருந்தது.
3. மாஸ்டர் கிளையில் இருந்து மாற்றங்கள்.

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

அதன் பிறகு, ஒரு அறிவிப்பு பாப்-அப் செய்யும், இது மறுசீரமைப்பு வெற்றிகரமாக இருந்தது என்று எங்களிடம் கூறுகிறது:

அங்கே! எங்கள் முதல் மோதலை IntelliJ IDEA மூலம் தீர்த்தோம்.

ரிமோட் சர்வரில் மாற்றங்களை அழுத்தவும்

அடுத்த கட்டமாக ரிமோட் சர்வரில் மாற்றங்களைத் தள்ளி இழுக்கும் கோரிக்கையை உருவாக்க வேண்டும். இதைச் செய்ய, CTRL+SHIFT+K ஐ அழுத்தவும் . பின்னர் நாம் பெறுகிறோம்:

இடதுபுறத்தில், ரிமோட் களஞ்சியத்திற்குத் தள்ளப்படாத கமிட்களின் பட்டியல் இருக்கும். வலதுபுறத்தில் மாற்றப்பட்ட அனைத்து கோப்புகளும் இருக்கும். அவ்வளவுதான்! புஷ் அழுத்தவும் , நீங்கள் மகிழ்ச்சியை அனுபவிப்பீர்கள் :)

புஷ் வெற்றிகரமாக இருந்தால், கீழ் வலது மூலையில் இது போன்ற அறிவிப்பைக் காண்பீர்கள்:

போனஸ்: இழுக்கும் கோரிக்கையை உருவாக்குதல்

நாம் ஒரு GitHub களஞ்சியத்திற்குச் செல்வோம், நாம் விரும்புவதை GitHub ஏற்கனவே அறிந்திருப்பதைக் காண்கிறோம்:

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

இப்போதைக்கு அவ்வளவுதான்!