Faili la .gitignore: jinsi ya kutenga faili kutoka Git na kuondoa zile zilizoongezwa tayari

Utaratibu wa git ignore ni njia ya kumwambia Git: «faili hizi usiziguse, usizionyeshe kwenye git status na usiziongeze kwa git add .». Kanuni zinaandikwa kwenye faili la maandishi .gitignore, ambalo linawekwa commit pamoja na mradi na linafanya kazi kwa timu nzima. Jambo la msingi: ignore inatumika tu kwa faili ambazo Git bado haifuatilii.

Kwa kawaida nini huongezwa kwenye .gitignore

• Utegemezi: node_modules/, vendor/, .venv/ — hurejeshwa na meneja wa vifurushi.
• Matokeo ya ujenzi: dist/, build/, *.class, __pycache__/.
• Logi na faili za muda: *.log, tmp/, *.swp.
• Siri na mipangilio ya ndani: .env, funguo, usanidi wa kompyuta yako.
• Takataka za mfumo na wahariri: .DS_Store, Thumbs.db, .idea/ — ingawa ni bora kuziweka kwenye ignore ya kimataifa, tazama hapa chini.

Kanuni rahisi: kwenye hifadhi kinapaswa kuwepo kile ambacho watu wanakiandika, si kile programu zinachozalisha au kinachotegemea kompyuta maalum.

Jinsi ya kuunda .gitignore

Ni faili la kawaida la maandishi kwenye mzizi wa hifadhi. Liunde, andika mifumo kwa mstari mmoja kila moja, kisha weka commit:

cat > .gitignore <<'EOF'
# utegemezi
node_modules/
# ujenzi
dist/
# logi
*.log
# siri
.env
EOF

git add .gitignore
git commit -m "chore: ongeza .gitignore"

Violezo vilivyotengenezwa tayari kwa lugha na mifumo maarufu vinapatikana kwenye hifadhi ya github/gitignore; GitHub na GitLab zinakupa kuchagua kiolezo wakati wa kuunda mradi. Vitumie kama msingi na ondoa kisichohitajika.

Sintaksia ya mifumo ya .gitignore

Jambo muhimu: mfumo usio na kufyeka ndani (config.json) unafanya kazi kwenye ngazi yoyote, na mfumo wenye kufyeka mwanzoni au katikati (/config.json, src/config.json) unahusiana na folda ambamo .gitignore hii iko.

Ubaguzi kwa alama ya mshangao

*.log
!important.log

Mtego: huwezi «kurudisha» faili ikiwa folda yake ya juu inatengwa. Git haiingii kwenye folda zilizotengwa, kwa hiyo hili halitafanya kazi:

logs/
!logs/keep.txt     # haifanyi kazi

Sahihi ni kutenga yaliyomo, si folda:

logs/*
!logs/keep.txt

Mbinu hiyo hiyo inatumika kuhifadhi folda tupu kwenye hifadhi: Git haihifadhi saraka tupu, kwa hiyo unaweka ndani yake faili .gitkeep na kuruhusu hilo pekee.

Mahali pengine pa kuweka ignore

Takataka za mfumo wako na IDE ni busara kuziweka kwenye ignore ya kimataifa, ili zisichafue .gitignore ya pamoja:

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

Ikiwa core.excludesFile haijawekwa, Git inasoma ~/.config/git/ignore, ikiwa faili hilo lipo.

Kwa nini .gitignore haifanyi kazi

Malalamiko ya kawaida zaidi: «niliongeza faili kwenye .gitignore, lakini Git bado inaonyesha mabadiliko». Sababu karibu kila mara ni moja — faili tayari inafuatiliwa. Ignore haiathiri faili ambazo zilishaingia kwenye commit.

Kukagua ni kanuni ipi inayofanya kazi (au kwa nini haifanyi kazi), git check-ignore inasaidia:

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

Matokeo yanaonyesha faili na mstari wa kanuni. Matokeo tupu yanamaanisha faili haitengwi. Sababu nyingine ya kushindwa ni nafasi mwishoni mwa mstari wa mfumo au usimbaji usio sahihi wa faili (kwa mfano UTF-16 ukiliunda kupitia PowerShell).

Jinsi ya kuondoa kwenye hifadhi faili iliyokwisha kuwekwa commit: git rm --cached

Amri git rm inafuta faili kutoka index na kutoka diski. Ukiongeza --cached — ni kutoka index tu: faili inabaki kwako, lakini inaacha kufuatiliwa.

echo ".env" >> .gitignore
git rm --cached .env
git commit -m "chore: .env haifuatiliwi tena"
git push

Kwa folda unahitaji -r:

git rm -r --cached node_modules/

Ikiwa kanuni nyingi zimebadilika na haijulikani nini kimeingia kwenye hifadhi, unaweza kujenga upya index yote: git rm -r --cached ., kisha git add . na commit. Kabla ya commit hakiki git status — hapo utaona faili zilizoondolewa kwenye index.

Angalizo: siri hubaki kwenye historia

git rm --cached inaondoa faili kutoka commits zinazofuata, lakini si kutoka zile za nyuma. Ikiwa nywila au tokeni iliingia kwenye hifadhi, inapatikana kwenye historia kwa yeyote mwenye nakala. Siri hiyo inapaswa kuchukuliwa kuwa imevuja na kutengenezwa upya. Historia inaweza kuandikwa upya kwa zana kama git filter-repo, lakini hilo linabadilisha hash za commits zote zinazofuata na linahitaji makubaliano na timu.

Athari nyingine: kwa wenzako, baada ya git pull, faili lililoondolewa kwenye index kwa --cached litafutwa kwenye diski yao. Kwa .env, waonye wenzako mapema, au weka kiolezo cha .env.example kwenye hifadhi.

git rm: kufuta faili

git rm old.py              # futa kutoka diski na index
git rm -r legacy/          # futa folda
git rm -n '*.tmp'          # dry run: onyesha kitakachofutwa
git rm -f changed.py       # futa faili lenye mabadiliko ambayo hayajawekwa commit

Ukifuta faili kwa rm ya kawaida, Git itaiona kama «deleted», na kufutwa lazima kuongezwe kupitia git add au git rm. git rm inafanya hatua zote mbili kwa wakati mmoja. Bila -f itakataa kufuta faili lenye mabadiliko ambayo hayajawekwa commit — hii ni kinga dhidi ya kupoteza kazi.

git mv: kubadilisha jina na kuhamisha

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

git mv ni kifupi cha mv + git rm ya njia ya zamani + git add ya mpya. Git haihifadhi ukweli wa kubadilisha jina: inaukadiria kwa kufanana kwa yaliyomo wakati wa kutoa git status, git log --follow na git diff. Kwa hiyo kubadilisha jina kwa git mv na mv ya kawaida ikifuatiwa na git add -A kunatoa matokeo sawa.

Ushauri wa vitendo: badilisha jina na ubadilishe yaliyomo ya faili kwenye commits tofauti. Faili ikibadilika sana pamoja na jina, Git inaweza kushindwa kulitambua kama faili lile lile, na historia kwa --follow itakatika.

Kwa kubadilisha herufi kubwa/ndogo tu kwenye jina la Windows na macOS (mifumo ya faili isiyojali herufi kubwa), tumia git mv readme.md README.md — kubadilisha jina kwenye Explorer kunaweza Git isilione.

Mpangilio wa kanuni na kipaumbele

Ndani ya faili moja kanuni zinasomwa kutoka juu kwenda chini, na ya mwisho inayolingana inashinda. Kwa hiyo ubaguzi !keep.log lazima uwe chini ya kanuni *.log, vinginevyo utafunikwa. Kati ya faili, kipaumbele ni hivi: .gitignore kwenye folda ndogo ina nguvu kuliko ile ya mzizi, na ignore ya kimataifa pamoja na .git/info/exclude zina kipaumbele cha chini kabisa.

Mfano wa .gitignore kwa mradi wa wavuti

Hapa chini ni toleo linalofanya kazi kwa mradi wa Node.js wenye backend ya Python. Angalia maoni: baada ya miezi sita hakuna atakayekumbuka kwa nini kanuni fulani iliongezwa.

# --- utegemezi ---
node_modules/
.venv/

# --- ujenzi na akiba ---
/dist
/build
__pycache__/
*.pyc
.pytest_cache/
coverage/

# --- logi ---
*.log
npm-debug.log*

# --- mazingira na siri ---
.env
.env.*
!.env.example

# --- mafaili ya watumiaji, lakini folda inabaki ---
uploads/*
!uploads/.gitkeep

Hapa kuna mbinu zote mbili za ubaguzi: .env.* inatenga mazingira yote ya ndani, lakini kiolezo .env.example kinabaki kwenye hifadhi, na folda uploads ipo kwenye clone kwa sababu ya .gitkeep.

Usichopaswa kutenga

Kutenga kupita kiasi pia ni hatari. Faili za kufunga utegemezi — package-lock.json, poetry.lock, composer.lock — kwenye programu kwa kawaida huwekwa commit: yanahakikisha kwamba wasanidi wote na CI wanasakinisha matoleo yale yale ya vifurushi. Mipangilio ya pamoja ya mpangilio wa msimbo (.editorconfig, mipangilio ya linters) pia inapaswa kuishi kwenye hifadhi.

Kesi yenye utata ni mipangilio ya IDE. Folda .vscode/ mara nyingi inatengwa yote, lakini wakati mwingine huwekwa commit pamoja na viendelezi vinavyopendekezwa na kazi za ujenzi: .vscode/*, kisha !.vscode/extensions.json. Uamuzi ni wa timu; jambo kuu ni kutoweka kwenye hifadhi ya pamoja njia za kibinafsi au funguo.

Mfano: umeweka node_modules kwenye commit kimakosa

Kosa la kawaida la wanaoanza: git add . kabla ya kuunda .gitignore, na maelfu ya faili yanaingia kwenye commit. Marekebisho ni hatua tatu:

echo "node_modules/" >> .gitignore
git rm -r --cached node_modules
git commit -m "chore: node_modules imeondolewa kwenye hifadhi"

Ikiwa commit bado haijatumwa kwenye seva, ni bora kuiandika upya ili faili nzito zisibaki kwenye historia: git reset --soft HEAD~1, kisha amri zile zile na commit mpya. Baada ya push faili tayari ziko kwenye historia, na ukubwa wa clone hautapungua bila kuandika upya historia.

Ili hili lisijirudie, unda .gitignore kabla ya git add ya kwanza, na zoea kuangalia git status kabla ya commit: orodha ndefu isiyo ya kawaida ya faili mpya ni sababu ya kusimama.

Muhtasari

Faili la .gitignore ndilo la kwanza kuwekwa commit kwenye mradi mpya: utegemezi, ujenzi, logi na siri hazihitajiki kwenye hifadhi. Ignore inafanya kazi kwa faili ambazo hazifuatiliwi tu, kwa hiyo zilizokwisha kuongezwa zinaondolewa kwa git rm --cached, na kanuni zinakaguliwa kwa git check-ignore -v. Kwa kufuta na kubadilisha jina tumia git rm na git mv, ili mabadiliko yaingie moja kwa moja kwenye index. Kufanya kazi na index na hifadhi ya kwanza kunafafanuliwa kwa vitendo katika kozi ya Git.