ஒரு சிக்கலான Git ரீபேஸை எவ்வாறு செயல்தவிர்ப்பது

ஒரு சிக்கலான Git ரீபேஸை மாற்றுதல்

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

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

Git Rebase ஐ செயல்தவிர்க்கும் செயல்முறையை எளிதாக்குதல்

மேலே கொடுக்கப்பட்டுள்ள ஸ்கிரிப்டுகள் சிக்கலான Git ரீபேஸை செயல்தவிர்க்கும் செயல்முறையை எளிதாக்க வடிவமைக்கப்பட்டுள்ளன. முதல் ஸ்கிரிப்ட் ரீபேஸை கைமுறையாக மாற்றுவதற்கு Git கட்டளைகளின் வரிசையைப் பயன்படுத்துகிறது. செயல்முறை தொடங்குகிறது git reflog, இது களஞ்சியத்தில் செய்யப்பட்ட அனைத்து மாற்றங்களையும் பட்டியலிடுகிறது, மறுதளத்திற்கு முன் கமிட் ஹாஷை அடையாளம் காண உதவுகிறது. அடுத்து, கட்டளை git checkout -b இந்த கமிட்டியிலிருந்து ஒரு புதிய தற்காலிக கிளையை உருவாக்கி சரிபார்க்கிறது. இது முக்கியமானது, ஏனெனில் இது உங்கள் களஞ்சியத்தின் நிலையை மறுதளத்திற்கு முன் தனிமைப்படுத்த அனுமதிக்கிறது. பின்னர், பயன்படுத்துவதன் மூலம் git reset --hard, இந்த தற்காலிக கிளையுடன் பொருந்துமாறு அசல் கிளையை மீட்டமைத்து, மறுதளத்தை திறம்பட செயல்தவிர்க்கிறீர்கள். இறுதியாக, தற்காலிக கிளை நீக்கப்பட்டது git branch -d சுத்தம் செய்ய.

இரண்டாவது ஸ்கிரிப்ட் இந்த முழு செயல்முறையையும் தானியங்குபடுத்தும் ஒரு பாஷ் ஸ்கிரிப்ட் ஆகும். இது ஒரு ஷெபாங் வரியுடன் தொடங்குகிறது, #!/bin/bash, இது பாஷ் ஷெல்லில் செயல்படுத்தப்பட வேண்டும் என்பதைக் குறிக்கிறது. ஸ்கிரிப்ட் சரியான எண்ணிக்கையிலான வாதங்களைப் பயன்படுத்தி வழங்கப்பட்டுள்ளதா என்பதைச் சரிபார்க்கிறது $#. இல்லையெனில், அது ஒரு பயன்பாட்டு செய்தியை அச்சிட்டு வெளியேறுகிறது exit 1, ஒரு பிழை சமிக்ஞை. ஸ்கிரிப்ட் பின்னர் குறிப்பிட்ட கமிட் பயன்படுத்தி ஒரு தற்காலிக கிளையை உருவாக்கி மாறுகிறது git checkout -b. இது அசல் கிளையை இந்த தற்காலிக கிளைக்கு மீட்டமைக்கிறது git reset --hard மற்றும் பயன்படுத்தி தற்காலிக கிளையை நீக்குகிறது git branch -d. இந்த ஸ்கிரிப்ட் செயல்முறையை நெறிப்படுத்துவது மட்டுமல்லாமல், கைமுறை பிழைகளின் அபாயத்தையும் குறைக்கிறது, மேலும் Git ரீபேஸை செயல்தவிர்க்க மிகவும் நம்பகமான வழியை உறுதி செய்கிறது.

git reflog
# Find the commit hash before the rebase
git checkout <commit_hash_before_rebase>
# Create a temporary branch from this commit
git checkout -b temp_branch
# Reset the original branch to this temporary branch
git checkout <original_branch>
git reset --hard temp_branch
git branch -d temp_branch
# Clean up temporary branch

#!/bin/bash
# Check for the correct number of arguments
if [ "$#" -ne 2 ]; then
  echo "Usage: $0 <original_branch> <commit_hash_before_rebase>"
  exit 1
fi
original_branch=$1
commit_hash_before_rebase=$2
# Create and switch to a temporary branch
git checkout -b temp_branch $commit_hash_before_rebase
# Reset the original branch to the temporary branch
git checkout $original_branch
git reset --hard temp_branch
# Delete the temporary branch
git branch -d temp_branch

ஒரு Git Rebase ஐ செயல்தவிர்ப்பதற்கான மேம்பட்ட நுட்பங்கள்

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

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