Git Cherry-Pick ஐப் புரிந்துகொள்வது: அது என்ன, எப்படி வேலை செய்கிறது

Arthur Petit

சனி, 29 ஜூன், 2024 ’அன்று’ பிற்பகல் 3:45:03

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

கட்டளை விளக்கம்

git checkout -b <branch-name> ஒரு புதிய கிளையை உருவாக்கி உடனடியாக அதற்கு மாறுகிறது.

echo "Some changes" >> file.txt file.txt கோப்பில் "சில மாற்றங்கள்" என்ற உரையைச் சேர்க்கிறது.

git add file.txt file.txt கோப்பினை உறுதிப் படுத்துவதற்கான படிநிலைகள்.

subprocess.run(command, shell=True, capture_output=True, text=True) பைத்தானில் ஷெல் கட்டளையை இயக்குகிறது, வெளியீட்டைக் கைப்பற்றி அதை உரையாகத் தருகிறது.

result.returncode துணைச் செயலாக்கக் கட்டளையின் ரிட்டர்ன் குறியீட்டைச் சரிபார்த்து, அது வெற்றிகரமாக இருந்ததா என்பதைத் தீர்மானிக்கிறது.

raise Exception(f"Command failed: {result.stderr}") துணை செயலாக்க கட்டளை தோல்வியுற்றால் பிழை செய்தியுடன் ஒரு விதிவிலக்கு எழுப்புகிறது.

கட்டளை	விளக்கம்
git checkout -b <branch-name>	ஒரு புதிய கிளையை உருவாக்கி உடனடியாக அதற்கு மாறுகிறது.
echo "Some changes" >> file.txt	file.txt கோப்பில் "சில மாற்றங்கள்" என்ற உரையைச் சேர்க்கிறது.
git add file.txt	file.txt கோப்பினை உறுதிப் படுத்துவதற்கான படிநிலைகள்.
subprocess.run(command, shell=True, capture_output=True, text=True)	பைத்தானில் ஷெல் கட்டளையை இயக்குகிறது, வெளியீட்டைக் கைப்பற்றி அதை உரையாகத் தருகிறது.
result.returncode	துணைச் செயலாக்கக் கட்டளையின் ரிட்டர்ன் குறியீட்டைச் சரிபார்த்து, அது வெற்றிகரமாக இருந்ததா என்பதைத் தீர்மானிக்கிறது.
raise Exception(f"Command failed: {result.stderr}")	துணை செயலாக்க கட்டளை தோல்வியுற்றால் பிழை செய்தியுடன் ஒரு விதிவிலக்கு எழுப்புகிறது.

கிட் செர்ரி-பிக் ஸ்கிரிப்ட்கள் எவ்வாறு செயல்படுகின்றன

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

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

Git Cherry-Pick உடன் குறிப்பிட்ட கமிட்களைப் பயன்படுத்துதல்

Git செயல்பாடுகளுக்கான ஷெல் ஸ்கிரிப்ட்

# Create a new branch
git checkout -b feature-branch

# Commit some changes
echo "Some changes" >> file.txt
git add file.txt
git commit -m "Add some changes"

# Switch to main branch
git checkout main

# Cherry-pick the commit from feature-branch
git cherry-pick <commit-hash>

பைதான் ஸ்கிரிப்ட்டில் கிட் செர்ரி-பிக் பயன்படுத்துதல்

Git Cherry-Pick ஐ தானியங்குபடுத்துவதற்கான பைதான் ஸ்கிரிப்ட்

import subprocess

# Function to run shell commands
def run_command(command):
    result = subprocess.run(command, shell=True, capture_output=True, text=True)
    if result.returncode != 0:
        raise Exception(f"Command failed: {result.stderr}")
    return result.stdout.strip()

# Example usage of cherry-pick
try:
    run_command("git checkout -b feature-branch")
    run_command("echo 'Some changes' >> file.txt")
    run_command("git add file.txt")
    run_command("git commit -m 'Add some changes'")
    run_command("git checkout main")
    run_command("git cherry-pick <commit-hash>")
    print("Cherry-pick successful!")
except Exception as e:
    print(f"An error occurred: {e}")

மேம்பட்ட கிட் செர்ரி-பிக்கிங் கருத்துகளை ஆராய்தல்

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

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

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

Git Cherry-Pick இன் மேம்பட்ட பயன்பாடு

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