.gitignore கோப்பு: Git-இலிருந்து கோப்புகளை விலக்குவது மற்றும் ஏற்கனவே சேர்த்ததை நீக்குவது

git ignore என்பது Git-க்குச் சொல்லும் ஒரு வழி: «இந்தக் கோப்புகளைத் தொடாதே, git status-இல் காட்டாதே, git add . மூலம் சேர்க்காதே». விதிகள் .gitignore என்ற உரைக் கோப்பில் எழுதப்படும்; அது திட்டத்துடன் சேர்ந்து commit ஆகி முழு குழுவுக்கும் பொருந்தும். முக்கியமான நுணுக்கம்: ignore விதி Git இன்னும் கண்காணிக்காத கோப்புகளுக்கு மட்டுமே வேலை செய்கிறது.

.gitignore-இல் பொதுவாக என்ன சேர்ப்பார்கள்

• சார்புகள்: node_modules/, vendor/, .venv/ — அவற்றை தொகுப்பு மேலாளர் மீண்டும் உருவாக்கும்.
• Build முடிவுகள்: dist/, build/, *.class, __pycache__/.
• பதிவுகளும் தற்காலிகக் கோப்புகளும்: *.log, tmp/, *.swp.
• ரகசியங்களும் உள்ளூர் அமைப்புகளும்: .env, விசைகள், உள்ளூர் configs.
• OS மற்றும் எடிட்டர் குப்பைகள்: .DS_Store, Thumbs.db, .idea/ — இவற்றை கீழே உள்ள உலகளாவிய ignore-இல் வைப்பது நல்லது.

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

.gitignore-ஐ உருவாக்குவது எப்படி

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

cat > .gitignore <<'EOF'
# зависимости
node_modules/
# сборка
dist/
# логи
*.log
# секреты
.env
EOF

git add .gitignore
git commit -m "chore: добавлен .gitignore"

பிரபல மொழிகள் மற்றும் கட்டமைப்புகளுக்கான ஆயத்த வார்ப்புருக்கள் github/gitignore களஞ்சியத்தில் உள்ளன; GitHub மற்றும் GitLab திட்டத்தை உருவாக்கும்போதே வார்ப்புருவைத் தேர்வு செய்ய வழங்கும். அவற்றை அடிப்படையாகக் கொண்டு தேவையற்றதை நீக்குங்கள்.

.gitignore தொடரியல் வடிவங்கள்

முக்கியமான நுணுக்கம்: நடுவில் slash இல்லாத வடிவம் (config.json) எந்த நிலையிலும் பொருந்தும்; தொடக்கத்தில் அல்லது நடுவில் slash உள்ள வடிவம் (/config.json, src/config.json) இந்த .gitignore உள்ள கோப்புறையைச் சார்ந்தது.

ஆச்சரியக்குறியுடன் விதிவிலக்குகள்

*.log
!important.log

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

logs/
!logs/keep.txt     # не работает

சரியான வழி — கோப்புறையை அல்ல, அதன் உள்ளடக்கத்தை விலக்குவது:

logs/*
!logs/keep.txt

இதே முறையில் காலியான கோப்புறையையும் களஞ்சியத்தில் வைக்கலாம்: Git காலி கோப்புறைகளைச் சேமிக்காது, அதனால் அதில் .gitkeep கோப்பை வைத்து அதை மட்டும் அனுமதிக்கிறார்கள்.

ignore விதியை வேறு எங்கே அமைக்கலாம்

உங்கள் OS மற்றும் IDE குப்பைகளை உலகளாவிய ignore-இல் வைப்பது பொது .gitignore-ஐ சுத்தமாக வைக்கும்:

git config --global core.excludesFile ~/.gitignore_global
echo ".DS_Store" >> ~/.gitignore_global
echo ".idea/" >> ~/.gitignore_global

core.excludesFile அமைக்கப்படவில்லை என்றால், ~/.config/git/ignore இருந்தால் Git அதைப் படிக்கும்.

.gitignore ஏன் வேலை செய்யவில்லை

மிகப் பொதுவான புகார்: «கோப்பை .gitignore-இல் சேர்த்தேன், ஆனால் Git இன்னும் மாற்றங்களைக் காட்டுகிறது». காரணம் கிட்டத்தட்ட எப்போதும் ஒன்றே — கோப்பு ஏற்கனவே கண்காணிக்கப்படுகிறது. ஒருமுறை commit-இல் சேர்ந்த கோப்புகளை ignore பாதிக்காது.

எந்த விதி வேலை செய்கிறது (அல்லது ஏன் வேலை செய்யவில்லை) என்று பார்க்க git check-ignore உதவும்:

git check-ignore -v logs/app.log
# .gitignore:3:*.log	logs/app.log

வெளியீடு கோப்பையும் விதியின் வரியையும் காட்டும். வெற்று வெளியீடு என்றால் கோப்பு விலக்கப்படவில்லை. இன்னொரு காரணம் — வடிவத்தின் இறுதியில் உள்ள இடைவெளிகள் அல்லது தவறான கோப்பு குறியாக்கம் (எ.கா. PowerShell-இல் உருவாக்கும்போது UTF-16).

ஏற்கனவே commit ஆன கோப்பை களஞ்சியத்திலிருந்து நீக்குவது: git rm --cached

git rm கோப்பை index-இலிருந்தும் வட்டிலிருந்தும் நீக்கும். --cached கொடியுடன் அது index-இலிருந்து மட்டும் நீக்கும்: கோப்பு உங்களிடம் இருக்கும், ஆனால் இனி கண்காணிக்கப்படாது.

echo ".env" >> .gitignore
git rm --cached .env
git commit -m "chore: .env больше не отслеживается"
git push

கோப்புறைக்கு -r தேவை:

git rm -r --cached node_modules/

நிறைய விதிகள் மாற்றப்பட்டு எது ஏற்கனவே களஞ்சியத்தில் சேர்ந்தது என்று தெளிவில்லையென்றால், index-ஐ முழுவதுமாக மீண்டும் உருவாக்கலாம்: git rm -r --cached ., பின்னர் git add . மற்றும் commit. Commit-க்கு முன் git status-ஐப் பாருங்கள் — index-இலிருந்து நீக்கப்பட்ட கோப்புகள் அங்கே தெரியும்.

எச்சரிக்கை: ரகசியங்கள் வரலாற்றில் தங்கும்

git rm --cached கோப்பை அடுத்த commit-களிலிருந்து நீக்கும், பழையவற்றிலிருந்து அல்ல. களஞ்சியத்தில் கடவுச்சொல் அல்லது டோக்கன் சேர்ந்திருந்தால், clone வைத்திருக்கும் எவருக்கும் அது வரலாற்றில் கிடைக்கும். அந்த ரகசியத்தை வெளிப்பட்டதாகக் கருதி மீண்டும் உருவாக்க வேண்டும். git filter-repo போன்ற கருவிகளால் வரலாற்றை மீண்டும் எழுதலாம், ஆனால் அது எல்லா பின்வரும் commit-களின் hash-களையும் மாற்றும்; குழுவுடன் ஒப்புக்கொள்ள வேண்டும்.

இன்னொரு விளைவு: --cached மூலம் index-இலிருந்து நீக்கப்பட்ட கோப்பு, சக ஊழியர்கள் git pull செய்யும்போது அவர்களின் வட்டிலிருந்தும் நீக்கப்படும். .env-க்கு முன்கூட்டியே குழுவை எச்சரியுங்கள், அல்லது களஞ்சியத்தில் .env.example வார்ப்புருவை வைத்திருங்கள்.

git rm: கோப்புகளை நீக்குவது

git rm old.py              # удалить с диска и из индекса
git rm -r legacy/          # удалить папку
git rm -n '*.tmp'          # dry run: показать, что будет удалено
git rm -f changed.py       # удалить файл с незакоммиченными изменениями

சாதாரண rm மூலம் கோப்பை நீக்கினால், Git அதை «deleted» என்று பார்க்கும்; நீக்கத்தை git add அல்லது git rm மூலம் சேர்க்க வேண்டும். git rm இரண்டு படிகளையும் ஒரே நேரத்தில் செய்யும். -f இல்லாமல் அது commit செய்யப்படாத மாற்றங்களுடைய கோப்பை நீக்க மறுக்கும் — இது வேலை இழப்பிலிருந்து பாதுகாப்பு.

git mv: பெயர் மாற்றுவது மற்றும் நகர்த்துவது

git mv utils.py helpers.py
git mv helpers.py src/helpers.py

git mv என்பது mv + பழைய பாதைக்கான git rm + புதிய பாதைக்கான git add ஆகியவற்றின் சுருக்கம். Git பெயர் மாற்றத்தை தனியாகச் சேமிப்பதில்லை: git status, git log --follow மற்றும் git diff வெளியீட்டின்போது உள்ளடக்கத்தின் ஒற்றுமையிலிருந்து அதைக் கணக்கிடுகிறது. அதனால் git mv மற்றும் சாதாரண mv-ஐத் தொடர்ந்து git add -A செய்தால் ஒரே முடிவு கிடைக்கும்.

நடைமுறை ஆலோசனை: பெயர் மாற்றத்தையும் உள்ளடக்க மாற்றத்தையும் வெவ்வேறு commit-களில் செய்யுங்கள். பெயர் மாற்றத்துடன் கோப்பு பெரிதும் மாறினால், Git அதை அதே கோப்பாக அடையாளம் காணாமல் போகலாம், --follow மூலம் வரலாறு அறுந்துவிடும்.

Windows மற்றும் macOS-இல் (கோப்பு முறைமைகள் எழுத்து அளவை வேறுபடுத்தாதவை) பெயரின் எழுத்து அளவை மட்டும் மாற்ற git mv readme.md README.md பயன்படுத்துங்கள் — சாதாரண பெயர் மாற்றத்தை Git கவனிக்காமல் போகலாம்.

விதிகளின் வரிசையும் முன்னுரிமையும்

ஒரே கோப்பில் விதிகள் மேலிருந்து கீழ் படிக்கப்படுகின்றன, பொருந்தும் கடைசி விதியே வெல்லும். அதனால் !keep.log விதிவிலக்கு *.log விதிக்குக் கீழே இருக்க வேண்டும், இல்லையென்றால் அது மறைக்கப்படும். கோப்புகளுக்கிடையே முன்னுரிமை: உள் கோப்புறையிலுள்ள .gitignore வேர் கோப்பை விட முக்கியம்; உலகளாவிய ignore மற்றும் .git/info/exclude மிகக் குறைந்த முன்னுரிமை கொண்டவை.

வலைத் திட்டத்திற்கான .gitignore எடுத்துக்காட்டு

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

# --- зависимости ---
node_modules/
.venv/

# --- сборка и кэши ---
/dist
/build
__pycache__/
*.pyc
.pytest_cache/
coverage/

# --- логи ---
*.log
npm-debug.log*

# --- окружение и секреты ---
.env
.env.*
!.env.example

# --- загрузки пользователей, но папку сохраняем ---
uploads/*
!uploads/.gitkeep

இங்கே விதிவிலக்குகளின் இரண்டு முறைகளும் உள்ளன: .env.* எல்லா உள்ளூர் சூழல் கோப்புகளையும் மறைக்கிறது, ஆனால் .env.example வார்ப்புரு களஞ்சியத்தில் இருக்கும்; uploads கோப்புறை .gitkeep மூலம் clone-இல் இருக்கும்.

எதை விலக்கக் கூடாது

அதிகமாக விலக்குவதும் கேடுதான். சார்பு பூட்டுக் கோப்புகள் — package-lock.json, poetry.lock, composer.lock — பயன்பாடுகளில் பொதுவாக commit செய்யப்படுகின்றன: எல்லா உருவாக்குநர்களுக்கும் CI-க்கும் ஒரே பதிப்புகள் நிறுவப்படுவதை அவை உறுதிசெய்கின்றன. பொதுவான வடிவமைப்பு அமைப்புகள் (.editorconfig, linter configs) களஞ்சியத்தில் இருக்க வேண்டும்.

சர்ச்சைக்குரிய வழக்கு — IDE அமைப்புகள். .vscode/ கோப்புறை பெரும்பாலும் முழுவதுமாக விலக்கப்படுகிறது, ஆனால் பரிந்துரைக்கப்பட்ட நீட்டிப்புகளும் build பணிகளும் சில நேரம் commit செய்யப்படுகின்றன: .vscode/*, பின்னர் !.vscode/extensions.json. முடிவை குழு எடுக்கும்; முக்கியமானது — பொதுக் களஞ்சியத்தில் தனிப்பட்ட பாதைகளையும் விசைகளையும் வைக்காமல் இருப்பது.

சூழ்நிலை: node_modules தற்செயலாக commit ஆனது

தொடக்கநிலையாளரின் உன்னதத் தவறு: .gitignore உருவாக்குவதற்கு முன் git add ., பின்னர் ஆயிரக்கணக்கான கோப்புகள் commit-இல் சேர்ந்துவிடுகின்றன. மூன்று படிகளில் சரிசெய்யலாம்:

echo "node_modules/" >> .gitignore
git rm -r --cached node_modules
git commit -m "chore: node_modules убраны из репозитория"

Commit இன்னும் சேவையகத்திற்கு அனுப்பப்படவில்லையென்றால், கனமான கோப்புகள் வரலாற்றில் தங்காமல் இருக்க அதை மீண்டும் எழுதுவது நல்லது: git reset --soft HEAD~1, பின்னர் அதே கட்டளைகள் மற்றும் புதிய commit. Push செய்த பின் கோப்புகள் ஏற்கனவே வரலாற்றில் உள்ளன; வரலாற்றை மீண்டும் எழுதாமல் clone-இன் அளவு குறையாது.

இது மீண்டும் நடக்காமல் இருக்க, முதல் git add-க்கு முன்பே .gitignore உருவாக்குங்கள், commit-க்கு முன் git status-ஐப் பாருங்கள்: புதிய கோப்புகளின் பட்டியல் சந்தேகத்திற்குரிய அளவில் நீளமாக இருந்தால் அங்கேயே நிறுத்துங்கள்.

சுருக்கம்

.gitignore — புதிய திட்டத்தில் முதலில் commit செய்ய வேண்டிய கோப்பு: சார்புகள், build-கள், பதிவுகள் மற்றும் ரகசியங்கள் களஞ்சியத்தில் தேவையில்லை. விலக்கல் கண்காணிக்கப்படாத கோப்புகளுக்கு மட்டுமே வேலை செய்கிறது; ஏற்கனவே சேர்ந்தவற்றை git rm --cached மூலம் நீக்குங்கள், விதிகளை git check-ignore -v மூலம் சரிபாருங்கள். நீக்குவதற்கும் பெயர் மாற்றுவதற்கும் git rm மற்றும் git mv பயன்படுத்துங்கள், அப்போது மாற்றங்கள் உடனே index-க்குச் செல்லும். Index மற்றும் முதல் களஞ்சியத்துடன் வேலை Git பாடநெறியில் நடைமுறையில் விளக்கப்பட்டுள்ளது.