Matawi (branches) kwenye Git: git branch, kuunda, kubadilisha na kufuta

Tawi kwenye Git ni nini

Tawi kwenye Git si nakala ya mradi, bali faili ndogo yenye hash ya commit moja. Kuunda tawi kunachukua sehemu ya sekunde na karibu hakuchukui nafasi, kwa sababu Git haiigi chochote: matawi yote yanaelekeza kwenye vitu vilevile ndani ya hifadhi. Unapofanya commit, kielekezi cha tawi la sasa kinasogea tu hadi kwenye commit mpya.

Hili linabadilisha mtazamo kuhusu matawi. Hayapaswi kuogopwa wala kuhifadhiwa kwa uchumi: tawi tofauti kwa kila kazi, marekebisho au jaribio ni mazoea ya kawaida. Jaribio likishindwa, tawi linafutwa, na historia kuu inabaki safi.

Unaweza kuona kwamba tawi ni faili kwa macho yako mwenyewe:

$ cat .git/refs/heads/main
8b7d4e2a9f1c0d3e5b6a7c8d9e0f1a2b3c4d5e6f

(Kwenye hifadhi kubwa baadhi ya marejeo yamefungashwa kwenye .git/packed-refs, kwa hiyo faili inaweza kukosekana — kiini hakibadiliki.)

HEAD kwenye Git: uko wapi sasa

HEAD ni kielekezi kinachoonyesha kile kilichopo «kwenye saraka ya kazi» kwa sasa. Kwa kawaida HEAD haielekezi kwenye commit, bali kwenye tawi:

$ cat .git/HEAD
ref: refs/heads/main

Mnyororo unaonekana hivi: HEAD → main → commit. Commit mpya itapata mzazi kuwa commit ambayo HEAD inaelekeza, kisha Git inasogeza tawi ambalo HEAD inaelekeza. Ndiyo sababu commits «zinaingia» kwenye tawi la sasa.

Ukihamia moja kwa moja kwenye commit au tagi (git switch --detach v1.0 au git checkout 3f2a1c9), HEAD itaelekeza kwenye commit moja kwa moja. Hali hii inaitwa detached HEAD. Kuangalia msimbo humo ni salama, lakini commits mpya hazifungamani na tawi lolote, na baada ya kuhama zinaweza kupotea kwa urahisi. Ukianza kubadilisha kitu, unda tawi hapo hapo: git switch -c fix-from-old-version.

Katika misemo, HEAD inatumika kama sehemu ya kuanzia: HEAD~1 ni commit iliyotangulia, HEAD~3 ni commits tatu nyuma, HEAD^2 ni mzazi wa pili wa commit ya merge.

Jinsi ya kuona matawi: git branch

git branch            # matawi ya ndani, la sasa limewekwa alama *
git branch -v         # pamoja na commit ya mwisho kila tawi
git branch -vv        # pamoja na upstream na kiasi kilichobaki nyuma/kilichozidi
git branch -r         # matawi ya mbali (origin/...)
git branch -a         # matawi yote
git branch --show-current   # jina la tawi la sasa pekee

Mfano wa matokeo ya git branch -vv:

  feature/login 4c1e2d7 [origin/feature/login: ahead 2] Fomu ya kuingia
* main          8b7d4e2 [origin/main] Sasisha README
  old-spike     1a9b3c0 Jaribio la cache

Hapa unaona kwamba feature/login ina commits mbili ambazo hazijatumwa, main inalingana na seva, na old-spike haina jozi yoyote kwenye seva.

Kuchuja matawi kunasaidiwa na git branch --merged (yameshaunganishwa kwenye la sasa — wagombea wa kufutwa), git branch --no-merged (bado hayajaunganishwa) na git branch --list 'feature/*' (kwa muundo).

Jinsi ya kuunda tawi

Kuna njia mbili. git branch huunda tawi lakini inakuacha kwenye la sasa:

git branch feature/login            # kutoka commit ya sasa
git branch hotfix v1.2.0            # kutoka tagi
git branch review 3f2a1c9           # kutoka commit maalum

Mara nyingi unataka kuunda tawi na kuhamia mara moja. Kwa hilo kuna git switch -c (ilionekana Git 2.23) au mbadala wa zamani git checkout -b:

git switch -c feature/login
git switch -c hotfix origin/main    # tawi jipya kutoka hali mpya ya seva

Tabia nzuri ni kusasisha msingi kabla ya kuunda tawi la kazi: git fetch, kisha git switch -c feature/x origin/main. Hivyo tawi linaanza na msimbo wa sasa, si na main yako ya ndani ambayo haijasasishwa kwa muda mrefu.

Jinsi ya kutaja matawi

Mikataba thabiti kwenye timu: kiambishi cha aina ya kazi na maelezo mafupi yaliyotenganishwa kwa kistari — feature/user-avatar, fix/login-timeout, chore/update-deps, wakati mwingine pamoja na namba ya kazi: feature/SHOP-142-cart. Haziruhusiwi nafasi, ~ ^ : ? * [, nukta mbili mfululizo, wala kuishia na .lock.

Jinsi ya kuhamia tawi: git switch

git switch main             # hamia tawi lililopo
git switch -                # rudi kwenye tawi lililotangulia
git switch feature/login    # ikiwa hakuna la ndani lakini kuna origin/feature/login,
                            # Git itaunda la ndani na kulifungamanisha na la mbali

Wakati wa kubadilisha tawi, Git inabadilisha faili kwenye saraka ya kazi kulingana na toleo la tawi lengwa. Mabadiliko ambayo hayajawekwa commit yanabebwa nawe ikiwa hayagongani na tawi lengwa. Yakigongana, Git inakataa:

error: Your local changes to the following files would be overwritten by checkout:
        app.js
Please commit your changes or stash them before you switch branches.

Suluhisho: weka commit, ficha kwa git stash (kisha rudisha kwa git stash pop), au hamisha mabadiliko kwa makusudi kwa kujaribu kuunganisha: git switch -m main. Bendera --discard-changes inatupa mabadiliko — itumie tu ikiwa hakika hauyahitaji.

Kwa nini git switch na si checkout? Checkout inaweza kubadilisha matawi, kuandika upya faili, na kwa sababu hiyo ni rahisi kukosea. Switch hufanya jambo moja tu — inafanya kazi na matawi — kwa hiyo ni salama zaidi. Ulinganisho wa kina wa checkout, switch na restore uko kwenye makala tofauti.

Jinsi ya kubadilisha jina la tawi

git branch -m new-name              # badilisha jina la la sasa
git branch -m old-name new-name     # badilisha jina la tawi lolote
git branch -M main                  # sawa na hilo, kwa kuandika juu ya tawi lililopo

Ikiwa tawi tayari lilikuwepo kwenye seva, kubadilisha jina ni la ndani tu. Tuma jipya na ufute la zamani:

git push -u origin new-name
git push origin --delete old-name

Jinsi ya kufuta tawi

git branch -d feature/login     # itafuta tu ikiwa tawi limeunganishwa
git branch -D old-spike         # itafuta kwa nguvu
git push origin --delete feature/login   # kufuta kwenye seva

-d inalinda dhidi ya kupoteza kazi: ikiwa tawi lina commits ambazo hazipo kwenye tawi la sasa (au upstream yake), Git inakataa kwa ujumbe «The branch 'x' is not fully merged». -D hufuta bila maswali. Tawi la sasa haliwezi kufutwa — kwanza hamia jingine.

Umefuta kimakosa? Commits hazitoweki mara moja. Tafuta hash ya commit ya mwisho ya tawi kwenye git reflog na urejeshe: git branch old-spike 1a9b3c0.

Alama za matawi ya mbali ambayo hayapo tena kwenye seva husafishwa na git fetch --prune.

Kuunganisha tawi la ndani na la mbali

Tawi la ndani linaweza kuwa na upstream — tawi la mbali ambalo linalinganishwa nalo na kusawazishwa. Linahitajika ili git push na git pull zifanye kazi bila hoja, na ili git status ionyeshe «ahead/behind».

git push -u origin feature/login                 # wakati wa kutuma mara ya kwanza
git branch --set-upstream-to=origin/main main    # kwa tawi lililopo
git branch --unset-upstream                      # ondoa uhusiano

Kuunganisha matawi: kwa ufupi

Matawi huundwa ili baadaye yaunganishwe. Kazi ikikamilika, hamia tawi lengwa na uunganishe lako ndani yake:

git switch main
git merge feature/login

Ikiwa main haijasonga mbele tangu tawi lilipoundwa, Git itafanya fast-forward: itasogeza tu kielekezi cha main hadi commit ya mwisho ya tawi, bila commit ya merge. Ikiwa matawi yote mawili yamepata commits mpya, itafanyika merge ya pande tatu: Git inatafuta babu wa pamoja, inalinganisha pande zote mbili na kuunda commit ya merge yenye wazazi wawili. Kwenye timu merge mara nyingi hufanywa kupitia pull request kwenye seva, na kwenye kompyuta yako unavuta tu main ya sasa.

Karatasi ya kudanganya ya matawi

Makosa ya kawaida ya wanaoanza

• Kazi moja kwa moja kwenye main. Ikiwa commits tayari zimefanywa lakini hazijatumwa, unda tawi hapo hapo (git branch feature/x), kisha rudisha main kwenye hali ya seva: git reset --hard origin/main (hakikisha kila kitu kimewekwa commit kwanza).
• Tawi kutoka main iliyopitwa na wakati. Kwanza git fetch, kisha tengeneza tawi kutoka origin/main.
• Commits kwenye detached HEAD. Kabla ya kuhama, unda tawi; ikiwa tayari umehama — tafuta commits kwenye git reflog.
• Matawi yanayoishi muda mrefu. Tawi linavyoishi kando kwa muda mrefu, ndivyo merge inavyouma zaidi. Vuta main mara kwa mara na uunganishe kazi kwa vipande vidogo.

Matawi katika kazi ya timu

Michakato ya timu hutofautiana, lakini karibu kila mahali kuna mojawapo ya mipango miwili. Katika GitHub Flow kuna tawi moja la muda mrefu main linalokuwa tayari kila wakati kwa kutolewa, pamoja na matawi mafupi ya feature yanayounganishwa kupitia pull request baada ya ukaguzi na majaribio ya CI. Katika Git Flow kuna develop, matawi ya kutolewa na matawi ya hotfix; mpango huu ni mzito zaidi na unafaa bidhaa zenye matoleo machache yenye nambari.

Bila kujali mpango, kanuni za pamoja zinafanya kazi: tawi moja kwa kazi moja, tawi linaishi siku badala ya miezi, kabla ya pull request tawi limesasishwa na main mpya, na baada ya kuunganishwa tawi linafutwa pande zote mbili, kwenye kompyuta yako na kwenye seva. Tawi kuu linalindwa kwa mipangilio ya hifadhi: push ya moja kwa moja na force push haziruhusiwi, kuunganisha ni kupitia ukaguzi tu.

Jinsi ya kuona historia ya matawi

Ili kuelewa jinsi matawi yanavyohusiana, grafu ndiyo njia rahisi zaidi: git log --oneline --graph --all inachora matawi yote na sehemu za kutengana kwenye terminal. Ili kuona commits zilizo kwenye tawi lakini bado hazijafika main, tumia git log main..feature/login, na tofauti ya faili — git diff main...feature/login (nukta tatu zinalinganisha na babu wa pamoja, yaani zinaonyesha mabadiliko ya tawi lenyewe tu).

Muhtasari

Tawi kwenye Git ni kielekezi cha bei nafuu kwa commit, na HEAD ni kielekezi cha tawi la sasa. git branch inasimamia matawi (orodha, kuunda, kubadilisha jina, kufuta), git switch inabadilisha kati yao, na git switch -c inafanya vitendo vyote viwili kwa pamoja. Matawi, HEAD, fast-forward na merge ya pande tatu vimefafanuliwa kwa mifano halisi katika kozi ya Git.