EN

Průvodce Gitem — větvení, merge, vracení

Praktický přehled gitu: staging a commitování, větvení a slučování, remote repozitáře, prohlížení historie, stashování a bezpečné vracení změn.

Co tato dovednost pokrývá

Běžné operace s gitem, které se objevují při normálním vývoji: konfigurace repozitáře, staging a commitování, větvení a slučování, synchronizace s remote, prohlížení historie, stashování rozpracované práce a — to, co je nejdůležitější zvládnout správně — bezpečné vracení změn. Pro souběžnou práci na více větvích v oddělených adresářích viz Git Worktrees , pro větvící model Gitflow viz Git Flow .

Kdy ji použít

  • Při hledání správného příkazu pro běžnou operaci s gitem
  • Při rozhodování, jak něco vrátit (necommitnuté změny, špatný commit, již pushnutý commit) bez ztráty práce
  • Při volbě mezi merge a rebase pro začlenění větve
  • Při zotavení z chyby (detached HEAD, špatná větev, omylem provedený reset) — viz Řešení problémů

Nastavení a konfigurace

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global init.defaultBranch main

git init                       # nový repozitář v aktuálním adresáři
git clone <url>                # kopie existujícího repozitáře
git clone <url> <dir>          # do pojmenovaného adresáře

Staging a commitování

git status                     # co se změnilo / je ve stagingu
git add <file>                 # zařadit konkrétní soubor
git add -p                     # zařazovat výběrově, po částech (hunk)
git add .                      # zařadit vše pod aktuálním adresářem

git commit -m "message"        # commitnout zařazené změny
git commit -am "message"       # zařadit sledované soubory + commit (vynechá nové)
git commit --amend             # přepsat poslední commit (jen pokud není pushnutý)

git add -p stojí za to zvyknout si — umožňuje zkontrolovat a rozdělit změny do soustředěných commitů místo commitování nesouvisející práce dohromady.

Větvení a slučování

git branch                     # výpis lokálních větví
git switch <branch>            # přepnout větev (moderní; nahrazuje checkout)
git switch -c <branch>         # vytvořit a přepnout
git branch -d <branch>         # smazat sloučenou větev
git branch -D <branch>         # vynutit smazání nesloučené větve

git merge <branch>             # sloučit <branch> do aktuální větve
git merge --no-ff <branch>     # vždy vytvořit merge commit

Merge vs rebase:

  • git merge zachovává historii přesně a vytváří merge commit — bezpečná výchozí volba, zvlášť pro sdílené větve.
  • git rebase <base> přehraje vaše commity nad <base> pro lineární historii — čistší, ale přepisuje hashe commitů.
  • Nikdy nerebasujte commity, které už ostatní stáhli. Přepsání sdílené historie vžene všechny ostatní do konfliktů.
git rebase main                # přehrát aktuální větev nad main
git rebase -i HEAD~3           # interaktivně squash/reword/reorder posledních 3 commitů

Rebase krok za krokem

Nejčastější použití: dostat do vlastní feature větve nové commity z main, aniž by vznikl merge commit.

git switch feature/login
git fetch origin
git rebase origin/main         # přehraje commity větve nad aktuální main

# při konfliktu: upravit soubory, pak
git add <file>
git rebase --continue          # další commit v pořadí
git rebase --abort             # nebo vše vrátit do stavu před rebase

git push --force-with-lease    # větev už byla pushnutá → hashe se změnily

Konflikt se při rebase řeší commit po commitu, takže se stejný soubor může ozvat víckrát. Když je to únavné, je git merge origin/main rovnocenná a levnější cesta.

Remote a synchronizace

git remote -v                  # výpis remotů
git remote add origin <url>    # přidat remote

git fetch                      # stáhnout změny z remote, neslučovat
git pull                       # fetch + merge do aktuální větve
git pull --rebase              # fetch + rebase (vyhne se merge commitu)

git push                       # pushnout aktuální větev
git push -u origin <branch>    # push a nastavení upstreamu (poprvé)
git push --force-with-lease    # bezpečný force-push — odmítne, pokud se remote nečekaně pohnul

Preferujte --force-with-lease před --force: stále odmítne přepsat práci, kterou někdo pushnul po vašem posledním fetchi, takže nepřepíšete commity kolegy.

Prohlížení historie

git log --oneline --graph --all   # kompaktní vizuální historie všech větví
git log -p <file>                 # historie s diffy pro jeden soubor
git show <commit>                 # zpráva a diff commitu
git diff                          # nezařazené změny
git diff --staged                 # zařazené změny
git blame <file>                  # kdo naposledy změnil každý řádek

Stashování

git stash                      # odložit necommitnuté změny, vyčistit strom
git stash -u                   # včetně nesledovaných souborů
git stash list                 # výpis stashů
git stash pop                  # znovu použít poslední stash a odstranit ho
git stash apply                # znovu použít, ale ponechat ve stash listu
git stash drop                 # zahodit stash

Stashování je pro rychlé přepnutí kontextu. Pro cokoliv déletrvajícího je větev (nebo worktree ) bezpečnější — stashe se snadno zapomenou a nemají název větve, který by připomněl, co obsahovaly.

Vracení změn

Správný příkaz závisí na tom, jak daleko změna došla. Od nejmírnějšího k nejdrastičtějšímu:

# Zahodit nezařazené změny souboru (nevratné — úpravy jsou pryč)
git restore <file>

# Vyřadit soubor ze stagingu, ale ponechat úpravy
git restore --staged <file>

# Vrátit poslední commit, ZACHOVAT změny ve stagingu
git reset --soft HEAD~1

# Vrátit poslední commit, ponechat změny v pracovním stromu (nezařazené)
git reset HEAD~1

# Vrátit poslední commit A zahodit jeho změny (destruktivní)
git reset --hard HEAD~1

# Vrátit commit novým commitem, který ho ruší (bezpečné pro sdílenou historii)
git revert <commit>

Pravidla:

  • Ještě není pushnuto → reset je v pořádku.
  • Už pushnuto / sdíleno → použijte revert, ne reset --hard + force-push.
  • git reset --hard a git restore trvale zahodí necommitnutou práci — není undo. Pokud si nejste jistí, nejdřív commitněte nebo stashněte.

Časté chyby

  • git add . bez kontroly. Do commitu se svezou logy, .env nebo build. Před commitem projděte git status a git diff --staged; co do repozitáře nepatří, dejte do .gitignore.
  • git push --force na sdílenou větev. Přepíše commity, které mezitím pushnul někdo jiný. Používejte --force-with-lease a jen na vlastní větvi.
  • Rebase sdílené větve. Kolegům se rozejde historie a vracejí staré commity zpět přes merge. Rebasujte jen to, co je zatím jen vaše.
  • git reset --hard s rozpracovanou prací. Necommitnuté změny jsou pryč a reflog je nezachrání. Nejdřív commit nebo git stash.
  • Jeden velký commit „WIP“. Nejde revertovat po částech ani rozumně zrevidovat. Dělte přes git add -p do commitů, z nichž každý dává smysl sám.
  • git pull do rozpracovaného stromu. Merge se pomíchá s vašimi úpravami. Před pullem commitněte nebo stashněte.
  • Zapomenuté stashe. git stash list po měsíci nikomu nic neřekne. Na víc než pár minut založte větev.

Řešení problémů

PříznakŘešení
Commit na špatnou větevgit switch <správná-větev> pak git cherry-pick <commit>; ze špatné větve ho odeberte přes git reset --hard HEAD~1 (pokud není pushnutý)
Detached HEAD (“not on a branch”)git switch -c <nová-větev> pro zachování commitů, nebo git switch main pro jejich zahození
Potřeba vrátit “smazaný” commitgit reflog vypíše nedávné pozice HEAD; git reset --hard <sha> nebo git switch -c rescue <sha>
Omylem reset --hardCommity obvykle stále existují — najděte je přes git reflog a obnovte
Merge konfliktUpravte označené soubory, git add je, pak git commit (nebo git merge --continue); git merge --abort pro ústup
Pushnuté tajemství (secret)Okamžitě tajemství rotujte — přepsání historie neodstraní expozici

Časté otázky

Jaký je rozdíl mezi git merge a git rebase?

git merge spojí dvě větve merge commitem a historii nemění. git rebase přehraje vaše commity nad jinou větev, takže historie zůstane lineární, ale commity dostanou nové hashe. Na vlastní, ještě nesdílené větvi je rebase v pořádku; sdílené větve slučujte přes merge.

Jak vrátit poslední commit v gitu?

Pokud commit ještě není pushnutý, git reset --soft HEAD~1 ho zruší a změny nechá ve stagingu. Pokud už je na remote, použijte git revert <commit> — vytvoří nový commit, který změny ruší, a nepřepisuje sdílenou historii.

K čemu je git stash?

git stash odloží rozpracované změny stranou a vrátí čistý pracovní strom, třeba když potřebujete rychle přepnout větev. git stash pop je vrátí zpět. Na delší odložení práce je bezpečnější větev nebo worktree.

Jak smazat větev lokálně i na remote?

Lokálně git branch -d <větev> (pro nesloučenou větev -D), na remote git push origin --delete <větev>. Zastaralé odkazy na smazané vzdálené větve uklidí git fetch --prune.

Co dělat, když git pull skončí konfliktem?

Otevřete soubory označené <<<<<<<, vyberte správnou podobu, uložte, git add je a dokončete přes git commit (při rebase git rebase --continue). Kdykoli můžete couvnout: git merge --abort nebo git rebase --abort vrátí stav před pullem.

← Zpět na úvod