git checkout, switch na restore: lipi lipi linatumika lini

Kwa nini git checkout ina majukumu mawili

git checkout kihistoria inafanya operesheni mbili tofauti kabisa. Ukiipa jina la tawi, inabadilisha HEAD na kusasisha saraka ya kazi. Ukiipa njia ya faili, inachukua toleo la faili kutoka kwenye index au commit na kuandika juu ya mabadiliko yako kimya kimya. Amri hiyo hiyo wakati mwingine huhamia kati ya matawi kwa usalama, na wakati mwingine hutupa kazi isiyohifadhiwa bila kurudi nyuma.

Kwa sababu hiyo, Git 2.23 ilileta amri mbili tofauti: git switch — kwa matawi, na git restore — kwa faili. Checkout haikuondolewa; inafanya kazi kikamilifu, lakini msimbo mpya, nyaraka na vidokezo vya Git yenyewe vinatumia switch na restore. Ukianza kujifunza, anza nazo; checkout bado inahitajika kuijua — inakutana katika maelekezo, scripts na kwenye mahojiano.

Ulinganisho wa amri

Zingatia -- kwenye amri za checkout. Hii ni alama ya kutenganisha: «njia zinakuja baadaye». Inazuia mkanganyiko pale faili na tawi vinapoitwa kwa jina moja. Kwenye restore tatizo hili halipo, kwa sababu amri inafanya kazi na faili pekee.

git checkout kwa matawi

git checkout feature/login        # hamia
git checkout -b feature/login     # unda kutoka commit ya sasa na uhamie
git checkout -b hotfix origin/main   # unda kutoka tawi la mbali
git checkout -t origin/feature/x  # tawi la ndani linalofuatilia la mbali

Ikiwa tawi la ndani halipo, lakini kwenye seva lipo tawi lenye jina hilo, git checkout feature/x (kama ilivyo git switch feature/x) itaunda tawi la ndani yenyewe na kuweka ufuatiliaji. Kabla ya hapo unahitaji git fetch, vinginevyo Git haijui kuhusu tawi jipya la mbali.

Kubadilisha tawi hakupotezi mabadiliko ambayo hayajawekwa commit: yanahamishwa kwenda tawi jingine ikiwa hayagongani nalo. Yakigongana, Git inakataa na kupendekeza kuweka commit au kuficha mabadiliko kwa git stash. Bendera -f (--force) itabadilisha tawi na kutupa mabadiliko ya ndani — hii tayari ni operesheni hatari.

git switch: matawi pekee

Switch inarudia sehemu ya matawi ya checkout, lakini kwa sheria kali zaidi. Tofauti kuu: haihami kwenda commit au tagi bila --detach wazi. Amri git switch v1.0 itatoa hitilafu badala ya kuhamia kimya kimya kwenye detached HEAD, kwa hiyo ni vigumu zaidi kujikuta «nje ya tawi» kwa bahati mbaya.

git switch main
git switch -c feature/cart
git switch -c feature/cart origin/main
git switch --detach v1.0
git switch -              # tawi lililotangulia
git switch -m main        # hamisha mabadiliko kwa merge ya pande tatu

git restore: kitufe cha kughairi kwa faili

Restore inarudisha faili kwenye hali iliyohifadhiwa na haibadilishi historia ya commits hata kidogo. Ili kuitumia kwa uhakika, kumbuka maeneo matatu ya Git: saraka ya kazi (unachokiona kwenye kihariri), index (kilichoandaliwa kwa git add) na commits.

Jinsi ya kughairi mabadiliko kwenye faili kabla ya git add

git restore app.js         # rudisha toleo kutoka kwenye index
git restore src/           # faili zote kwenye folda
git restore .              # faili zote zilizobadilishwa za mradi

Bila bendera, restore inarejesha saraka ya kazi kutoka kwenye index. Ikiwa faili haikuongezwa kwenye index baada ya commit ya mwisho, hiyo ni sawa na toleo la commit ya mwisho. Mabadiliko yanatoweka bila alama, hayaendi kwenye takataka, kwa hiyo kabla ya git restore . angalia kwanza git diff.

Jinsi ya kuondoa faili kwenye index baada ya git add

git restore --staged app.js

Faili inaacha kuwa tayari kwa commit, lakini mabadiliko yako ndani yake yanabaki. Hii ndiyo aina salama zaidi ya restore: hakuna kinachopotea. Ndiyo amri ambayo git status inapendekeza katika sehemu ya «Changes to be committed».

Jinsi ya kughairi kila kitu: index na faili

git restore --staged --worktree app.js
# fomu fupi
git restore -SW app.js

Jinsi ya kurudisha faili kutoka commit au tawi lingine

git restore --source=HEAD~2 app.js          # toleo la commits mbili nyuma
git restore --source=main config.yml        # toleo kutoka tawi main
git restore --source=3f2a1c9 -- docs/       # folda nzima kutoka commit

Kwa chaguo-msingi, --source inabadilisha saraka ya kazi pekee. Ongeza --staged ukitaka kuandaa mabadiliko kwa commit mara moja. Njia ya zamani git checkout main -- app.js inabadilisha index na saraka ya kazi kila wakati.

Jinsi ya kurejesha faili iliyofutwa

git restore deleted.txt                          # imefutwa, lakini bado haijawekwa commit
git restore --source=HEAD~1 deleted.txt          # kufutwa tayari kumewekwa commit

Ikiwa hujui faili ilifutwa kwenye commit ipi, itafute: git log --oneline -- deleted.txt. Commit ya mwisho kwenye orodha ndiyo iliyofuta faili, na kuirejesha inabidi kutoka kwa mzazi wake: git restore --source=<hash>~1 deleted.txt.

restore, reset na revert: zisichanganywe

Amri zote tatu «zinaghairi», lakini katika kina tofauti:

• restore — inafanya kazi na faili kwenye saraka ya kazi na index, haibadilishi historia. Ni salama kwa timu.
• reset — inasogeza kielekezi cha tawi nyuma, ikiandika upya historia. --soft inabakiza mabadiliko kwenye index, --mixed (chaguo-msingi) — kwenye saraka ya kazi, --hard inayafuta. Ni hatari kwa commits zilizotumwa kwenye matawi ya pamoja.
• revert — inaunda commit mpya inayopinga ile uliyoitaja. Historia haiandikwi upya, kwa hiyo ndiyo njia sahihi ya kughairi commit ambayo tayari iko kwenye seva.

Kanuni rahisi: mabadiliko bado hayajawekwa commit — restore; commit ni ya ndani tu — reset; commit tayari iko kwa wenzako — revert.

Detached HEAD baada ya checkout

Ukiendesha git checkout 3f2a1c9 au git checkout v1.0, utaona onyo refu «You are in 'detached HEAD' state». HEAD sasa inaelekeza kwenye commit, si tawi. Hii ni rahisi kuangalia toleo la zamani au kuendesha majaribio juu yake.

Unaweza kufanya commit katika hali hii, lakini commits mpya hazitaingia kwenye tawi lolote. Ikiwa umebadilisha kitu na unataka kukihifadhi:

git switch -c fix-for-v1

Ikiwa umeangalia tu — rudi: git switch - au git switch main. Ukiondoka bila kuunda tawi, commits bado zinapatikana kupitia git reflog: pata hash na utekeleze git branch rescue <hash>.

Makosa ya kawaida

error: pathspec 'feature' did not match any file(s) known to git

Git haikupata tawi wala faili yenye jina hilo. Kwa kawaida tawi lipo kwenye seva tu, na fetch haijafanywa. Tekeleza git fetch kisha rudia. Angalia pia tahajia: majina ya matawi yanajali herufi kubwa na ndogo.

Nilitupa mabadiliko kwa bahati mbaya kwa checkout -- au restore

Git haihifadhi mabadiliko ambayo hayakuwa kwenye index, kwa hiyo hayawezi kurejeshwa kwa zana za Git. Unabaki na historia ya kihariri au IDE yako. Lakini ikiwa faili iliwahi kuongezwa kwa git add, maudhui yake yapo kwenye hifadhidata kama kitu «kinachoelea», na yanapatikana kwa git fsck --lost-found.

Faili na tawi zenye jina moja

git checkout test ikiwa kuna tawi test na folda test itatoa onyo la utata. Tumia git switch test kwa tawi, na git restore test (au git checkout -- test) kwa faili.

Hali za kila siku za kazi

Baadhi ya hali zinazojitokeza kila mara, na amri sahihi kwa kila moja:

• Umeanza kuhariri faili na umegundua umeenda upande mbaya — git restore faili.
• Umeongeza kwenye index faili la ziada kabla ya commit — git restore --staged faili.
• Unahitaji kuhamia kazi nyingine ghafla katikati ya kazi — git stash, kisha git switch tawi; ukirudi — git switch - na git stash pop.
• Unataka kuchukua faili moja kutoka tawi jirani bila kuunganisha tawi zima — git restore --source=feature/x --staged --worktree njia.
• Unataka kuangalia kama hitilafu ilikuwepo kwenye toleo la zamani — git switch --detach v1.0, ukaguzi, kisha git switch -.
• Unataka kughairi sehemu tu ya mabadiliko kwenye faili — git restore -p faili: Git itaonyesha kila sehemu na kuuliza kama uighairi.

Hali ya mwingiliano -p (--patch) ni muhimu sana: ipo kwenye checkout na restore zote mbili, na inakuwezesha kutupa msimbo wa uchunguzi huku ukihifadhi mabadiliko muhimu kwenye faili hiyo hiyo.

Jinsi ya kuangalia matokeo kabla ya kughairi

Restore na checkout zenye njia zinatupa mabadiliko bila uthibitisho, kwa hiyo ni busara kuona kwanza kitakachopotea. git diff inaonyesha mabadiliko ya saraka ya kazi dhidi ya index, git diff --staged — kilichoandaliwa kwa commit, git diff main -- app.js — faili inavyotofautiana na toleo la tawi lingine. Ukiwa na shaka, hifadhi hali ya sasa kwa git stash: kutoka humo mabadiliko yanaweza kurudishwa wakati wowote, tofauti na restore.

Muhtasari

git checkout inachanganya kubadilisha matawi na kurejesha faili, na hilo ndilo linalofanya iwe hatari. Kwa matawi tumia git switch, kwa faili — git restore: amri moja inabadilisha nafasi ya HEAD tu, nyingine inabadilisha maudhui ya faili tu. Matawi, restore, reset na revert pamoja na hali nzuri na mbaya zimefafanuliwa kwa vitendo katika kozi ya Git.