Git களஞ்சியத்திலிருந்து ஒரு கோப்பை உள்ளூரில் நீக்காமல் எப்படி அகற்றுவது

உள்ளூர் நீக்கம் இல்லாமல் Git கோப்புகளை நிர்வகித்தல்

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

வழக்கமான `git rm` கட்டளையானது களஞ்சியம் மற்றும் உள்ளூர் கோப்பு முறைமை இரண்டிலிருந்தும் கோப்பை அகற்றும், இது எப்போதும் விரும்பத்தக்கதல்ல. அதிர்ஷ்டவசமாக, உங்கள் உள்ளூர் நகலை அப்படியே வைத்திருக்கும் போது, ​​களஞ்சியத்திலிருந்து கோப்பை அகற்றுவதற்கான வழியை Git வழங்குகிறது. இந்த வழிகாட்டியில், இந்த பணியை திறமையாக நிறைவேற்றுவதற்கான படிகளை நாங்கள் ஆராய்வோம்.

Git கோப்பு அகற்றும் ஸ்கிரிப்ட்களின் விரிவான விளக்கம்

வழங்கப்பட்ட ஸ்கிரிப்ட்கள் உள்ளூர் கோப்பு முறைமையிலிருந்து ஒரு கோப்பை நீக்காமல் Git களஞ்சியத்திலிருந்து அகற்றுவதை நோக்கமாகக் கொண்டுள்ளன. இதை அடைய முதல் ஸ்கிரிப்ட் தொடர்ச்சியான Git கட்டளைகளைப் பயன்படுத்துகிறது. ஆரம்பத்தில், தி git reset HEAD <file> கோப்பினை நிலை குலையச் செய்ய கட்டளை பயன்படுத்தப்படுகிறது, இது அடுத்த கமிட்டின் பகுதியாக இல்லை என்பதை உறுதிப்படுத்துகிறது. இதைத் தொடர்ந்து, தி git rm --cached <file> கட்டளை Git குறியீட்டிலிருந்து கோப்பை நீக்குகிறது, கோப்பை உள்நாட்டில் நீக்காமல் கண்காணிப்பதை நிறுத்துமாறு Git ஐ திறம்பட கூறுகிறது. கோப்பு இனி களஞ்சியத்தின் ஒரு பகுதியாக இல்லை என்பதை உறுதிப்படுத்தும் போது, ​​உள்ளூர் நகல் இழப்பைத் தடுக்கும் இந்த படிகள் முக்கியமானவை.

அடுத்த முக்கியமான படியில் கோப்பைச் சேர்ப்பது அடங்கும் .gitignore கட்டளையைப் பயன்படுத்தி கோப்பு echo "<file>" >> .gitignore. எதிர்கால கமிட்களில் கோப்பு கண்காணிக்கப்படாமல் இருப்பதை உறுதிசெய்ய, தற்செயலாக மீண்டும் சேர்க்கப்படுவதைத் தவிர்க்க இந்தப் படி அவசியம். ஒரு முறை .gitignore கோப்பு புதுப்பிக்கப்பட்டது, அதைப் பயன்படுத்தி அடுத்த உறுதிப்பாட்டிற்கு அதைச் செயல்படுத்த வேண்டும் git add .gitignore. இறுதியாக, மாற்றங்கள் கட்டளையுடன் களஞ்சியத்திற்கு உறுதியளிக்கப்படுகின்றன git commit -m "<message>". இந்த உறுதியானது செயல்முறையை திறம்பட முடிக்கிறது, உள்ளூர் நகலை அப்படியே வைத்திருக்கும் அதே வேளையில் களஞ்சியத்திலிருந்து அகற்றுவதை அதிகாரப்பூர்வமாக்குகிறது.

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

Git களஞ்சியத்திலிருந்து ஒரு கோப்பை உள்நாட்டில் வைத்திருக்கும் போது அதை எவ்வாறு விலக்குவது

Git கட்டளை வரியைப் பயன்படுத்துதல்

# Step 1: Ensure the file is not currently staged
git reset HEAD file_to_remove.txt

# Step 2: Remove the file from the index
git rm --cached file_to_remove.txt

# Step 3: Add the file to .gitignore to prevent future commits
echo "file_to_remove.txt" >> .gitignore

# Step 4: Commit the changes
git add .gitignore
git commit -m "Remove file_to_remove.txt from repository but keep it locally"

ஷெல் ஸ்கிரிப்டைப் பயன்படுத்தி ஜிட் களஞ்சியத்திலிருந்து ஒரு கோப்பைத் தவிர்த்து

பாஷ் ஸ்கிரிப்டைப் பயன்படுத்துதல்

#!/bin/bash

# Function to remove file from Git repository but keep it locally
remove_file_from_git() {
  local file=$1
  git reset HEAD $file
  git rm --cached $file
  echo "$file" >> .gitignore
  git add .gitignore
  git commit -m "Remove $file from repository but keep it locally"
}

# Usage
remove_file_from_git "file_to_remove.txt"

உள்ளூர் கோப்பு முறைமையைப் பாதிக்காமல் Git களஞ்சியத்திலிருந்து கோப்புகளை அகற்றுதல்

Git களஞ்சியத்தில் கோப்புகளைக் கையாள்வதில் மற்றொரு முக்கிய அம்சம் .gitignore இன் தாக்கங்கள் மற்றும் கண்காணிக்கப்பட்ட மற்றும் கண்காணிக்கப்படாத கோப்புகளுடன் எவ்வாறு தொடர்பு கொள்கிறது என்பதைப் புரிந்துகொள்வது. நீங்கள் ஒரு கோப்பை .gitignore இல் சேர்க்கும்போது, ​​​​கோப்பைக் கண்காணிப்பதை நிறுத்துமாறு Git கூறுகிறது, இது உங்கள் உள்ளூர் கணினியில் இருக்கும் ஆனால் உள்ளமைவு கோப்புகள் அல்லது உள்ளூர் மேம்பாட்டு சூழல்கள் போன்ற களஞ்சியத்தின் ஒரு பகுதியாக இருக்காத கோப்புகளுக்கு பயனுள்ளதாக இருக்கும். இருப்பினும், .gitignore கண்காணிக்கப்படாத கோப்புகளை மட்டுமே பாதிக்கும் என்பதைக் கவனத்தில் கொள்ள வேண்டும். ஒரு கோப்பு ஏற்கனவே Git ஆல் கண்காணிக்கப்பட்டால், அதை .gitignore இல் சேர்ப்பதால், குறியீட்டிலிருந்து அதை அகற்றும் வரை எந்த விளைவையும் ஏற்படுத்தாது. git rm --cached <file>.

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

உள்ளூரில் நீக்காமல் Git இலிருந்து கோப்புகளை அகற்றுவது பற்றிய பொதுவான கேள்விகள்

1. Git இண்டெக்ஸிலிருந்து ஒரு கோப்பை எப்படி அகற்றுவது ஆனால் அதை உள்ளூரில் வைத்திருப்பது எப்படி?
2. கட்டளையைப் பயன்படுத்தவும் git rm --cached <file> உங்கள் உள்ளூர் கோப்பு முறைமையில் வைத்திருக்கும் போது குறியீட்டிலிருந்து கோப்பை அகற்றவும்.
3. .gitignore இன் நோக்கம் என்ன?
4. .gitignore எந்த கோப்புகள் அல்லது கோப்பகங்களை Git புறக்கணிக்க வேண்டும் மற்றும் கண்காணிக்கக்கூடாது என்பதைக் குறிப்பிட பயன்படுகிறது.
5. ஏற்கனவே ட்ராக் செய்யப்பட்டு வரும் கோப்பை கண்காணிப்பதை நிறுத்த .gitignore ஐப் பயன்படுத்தலாமா?
6. இல்லை, நீங்கள் முதலில் குறியீட்டிலிருந்து கோப்பை அகற்ற வேண்டும் git rm --cached <file> பின்னர் அதை .gitignore இல் சேர்க்கவும்.
7. நான் ஒரு கோப்பை களஞ்சியத்திலிருந்து அகற்றினாலும் அதை .gitignore இல் சேர்க்காவிட்டால் என்ன நடக்கும்?
8. நீங்கள் அதை .gitignore இல் சேர்க்கவில்லை எனில், கோப்பினை மாற்றியமைத்து, ஒரு உறுதிப்பாட்டிற்காக கட்டமைத்தால் Git அதை மீண்டும் கண்காணிக்கலாம்.
9. Git இலிருந்து கோப்புகளை அகற்றி உள்நாட்டில் வைத்திருக்கும் செயல்முறையை நான் எவ்வாறு தானியங்குபடுத்துவது?
10. போன்ற கட்டளைகளைப் பயன்படுத்தும் ஷெல் ஸ்கிரிப்டை நீங்கள் உருவாக்கலாம் git reset HEAD <file> மற்றும் git rm --cached <file> செயல்முறையை தானியக்கமாக்க.
11. .gitkeep என்றால் என்ன, அது எவ்வாறு பயன்படுத்தப்படுகிறது?
12. .gitkeep வெற்று கோப்பகங்கள் ஒரு களஞ்சியத்தில் கண்காணிக்கப்படுவதை உறுதிசெய்யப் பயன்படுத்தப்படும் ஒதுக்கிடக் கோப்பு.
13. ஏன் Git வெற்று கோப்பகங்களைக் கண்காணிக்கவில்லை?
14. Git கோப்புகளை மட்டுமே கண்காணிக்கும், எனவே வெற்று கோப்பகங்கள் குறைந்தபட்சம் ஒரு கோப்பைக் கொண்டிருக்கும் வரை புறக்கணிக்கப்படும்.
15. Git இண்டெக்ஸில் இருந்து ஒரே நேரத்தில் பல கோப்புகளை நீக்க முடியுமா?
16. ஆம், நீங்கள் பயன்படுத்தலாம் git rm --cached <file1> <file2> ... ஒரே நேரத்தில் குறியீட்டில் இருந்து பல கோப்புகளை நீக்க.
17. Git ஆல் புறக்கணிக்கப்படும் கோப்புகளைக் காட்சிப்படுத்த வழி உள்ளதா?
18. நீங்கள் பயன்படுத்தலாம் git status --ignored புறக்கணிக்கப்பட்ட அனைத்து கோப்புகள் மற்றும் கோப்பகங்களை பட்டியலிட.

பயனுள்ள Git கோப்பு மேலாண்மை

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

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