Lidsky řečeno
Znáš složku se soubory smlouva.docx, smlouva_final.docx, smlouva_final2.docx a smlouva_final_OPRAVDU.docx? Git je pořádná verze téhož nápadu. Funguje jako uložené pozice ve hře: kdykoli si stav uložíš, k jakémukoli se vrátíš a můžeš si zkusit riskantní odbočku, aniž bys ohrozil hlavní postup. A protože si pozice umí vyměňovat i s ostatními, může na jednom projektu pracovat celý tým.
První repozitář a první commit
Repozitář je složka projektu, u které Git vede historii. Commit je jedna uložená pozice: stav souborů v daném okamžiku, autor, čas a popis změny. Příkazy se píšou do terminálu. Git si jednou nastav a potom založ projekt.
git config --global user.name "Eva Nováková"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main
mkdir rozpocet && cd rozpocet
git initSoubor neputuje do historie sám. Prochází třemi místy:
pracovní složka přípravna (staging) repozitář
soubory, jak je vidíš co půjde do commitu uložená historie
| | |
|------ git add -------->| |
| |------ git commit ------>|
|<----------------- git restore -------------------|Přípravna vypadá jako zbytečný krok navíc. Díky ní ale můžeš z deseti rozdělaných změn commitnout jen ty tři, které spolu souvisí.
echo 'print("rozpočet")' > app.py
git status --short # ?? app.py Git soubor ještě nesleduje
git add app.py
git status --short # A app.py soubor je v přípravně
git commit -m "Přidej základ aplikace"
echo 'print("verze 2")' >> app.py
git status --short # M app.py změněno, zatím nepřidáno
git diff # co přesně se změnilo
git add app.py
git commit -m "Vypiš číslo verze"
git log --oneline # přehled historieCo je commit doopravdy
Git je v jádru jednoduchý: databáze objektů, kde klíčem je otisk (hash) obsahu. Otisk je dlouhé číslo vypočítané z dat. Stejná data dají vždycky stejný otisk, a i nepatrná změna dá úplně jiný. Obsah souboru se ukládá jako blob a jeho otisk si spočítáš sám.
import hashlib
def blob_hash(obsah: bytes) -> str:
hlavicka = f"blob {len(obsah)}\0".encode()
return hashlib.sha1(hlavicka + obsah).hexdigest()
print(blob_hash(b"ahoj\n"))
print(blob_hash(b"Ahoj\n"))
36a0e7cf17ffe584221529d45113d821e70764a9 2de7c0609e3ec3fce247348848749f8369805d39
Výsledek odpovídá příkazu git hash-object, který dělá totéž:
printf 'ahoj\n' | git hash-object --stdinObjekty do sebe zapadají. Tree je výpis složky: jména souborů a otisky jejich obsahu. Commit je krátký text s otiskem tree, otiskem předchozího commitu (rodiče), autorem a zprávou. Tady je celý commit sestavený v Pythonu.
import hashlib
def objekt(typ: str, data: bytes) -> str:
return hashlib.sha1(f"{typ} {len(data)}\0".encode() + data).hexdigest()
def tree(soubory: dict[str, bytes]) -> str:
data = b""
for jmeno in sorted(soubory):
otisk = bytes.fromhex(objekt("blob", soubory[jmeno]))
data += f"100644 {jmeno}\0".encode() + otisk
return objekt("tree", data)
def commit(strom: str, rodic: str | None, zprava: str) -> str:
kdo = "Eva <[email protected]> 1700000000 +0100"
radky = [f"tree {strom}"]
if rodic:
radky.append(f"parent {rodic}")
radky += [f"author {kdo}", f"committer {kdo}", "", zprava, ""]
return objekt("commit", "\n".join(radky).encode())
strom = tree({"app.py": b'print("ahoj")\n'})
prvni = commit(strom, None, "Start")
druhy = commit(strom, prvni, "Prázdná změna")
print("tree ", strom)
print("commit ", prvni)
print("commit ", druhy)
print("jiný předek:", commit(strom, druhy, "Prázdná změna"))
tree 2bc1d18143addc2deab86abe0bcbab0ac11f4677 commit 077010dba3d867e5e5e0fc8a2a5a7f8319dc24dd commit 6b49b249b43d925322eeedb15a6761d32960c1ed jiný předek: 82ebf4f6988de5d42f91c62061efd4f85109cd6d
Z toho plyne několik věcí, které jinak vypadají jako magie:
- Commit je celý snímek projektu, ne seznam rozdílů. Diff si Git dopočítá porovnáním dvou snímků.
- Soubor, který se nezměnil, se neukládá znovu. Má stejný otisk, takže stačí odkaz.
- Otisk commitu závisí na otisku rodiče. Změnou staršího commitu se změní všechny po něm, a proto historii nejde nepozorovaně přepsat.
Otisk jako v Gitu
Napiš funkci git_blob(text), která dostane řetězec a vrátí jeho otisk stejně jako git hash-object. Text převeď na bajty v UTF-8. Do hlavičky patří počet bajtů, ne znaků.
import hashlib
def git_blob(text):
return hashlib.sha1(text.encode()).hexdigest()
Pod kapotou · objekty na disku
Objekty leží v .git/objects/36/a0e7cf... komprimované zlibem. První dva znaky otisku tvoří složku. Prozkoumáš je příkazem git cat-file -p HEAD a git cat-file -p 'HEAD^{tree}'. Při úklidu (git gc, nově spíš git maintenance) se balí do packfiles s delta kompresí, takže úspora je na úrovni úložiště, zatímco logický model zůstává snímkový.
Git používá SHA-1 se zapnutou detekcí kolizních útoků (SHA-1DC) a umí i repozitáře se SHA-256 přes git init --object-format=sha256. Otisk není podpis: říká, že se obsah nezměnil, ne kdo ho vytvořil. Pole author si může napsat kdokoli cokoli, proto existuje podepisování commitů přes gpg.format=ssh nebo GPG.
Autor a committer jsou dvě různé role. Po rebase nebo cherry-picku zůstává autor a mění se committer včetně času, což je důvod, proč se otisk změní i při „stejném“ kódu.
Větve jsou jen ukazatele
Větev zní jako těžká kopie projektu. Ve skutečnosti je to malý soubor s otiskem jednoho commitu, proto je vytvoření okamžité. HEAD je značka „tady právě jsem“ a obvykle ukazuje na větev. Nový commit posune větev, na které stojíš.
git switch -c feature/export # vytvoř větev a přejdi na ni
git branch # seznam větví
git switch main # zpět na main
git branch -d feature/export # smaž už sloučenou větev
git log --oneline --graph --all # historie jako grafA---B---C main
\
D---E feature/export <- HEADHistorie je graf: každý commit zná své rodiče. Běžná operace je najít společného předka dvou větví, tedy bod, kde se rozešly. Odtud Git počítá, co která větev změnila.
COMMITY = {
"A": [],
"B": ["A"],
"C": ["B"],
"D": ["B"],
"E": ["D"],
}
VETVE = {"main": "C", "feature": "E"}
def historie(commit):
poradi = []
fronta = [commit]
while fronta:
aktualni = fronta.pop(0)
if aktualni not in poradi:
poradi.append(aktualni)
fronta.extend(COMMITY[aktualni])
return poradi
print("main: ", historie(VETVE["main"]))
print("feature:", historie(VETVE["feature"]))
jen_feature = [c for c in historie(VETVE["feature"]) if c not in historie(VETVE["main"])]
print("main..feature:", jen_feature)
main: ['C', 'B', 'A'] feature: ['E', 'D', 'B', 'A'] main..feature: ['E', 'D']
Poslední řádek je přesně to, co ukáže git log main..feature: commity dosažitelné z feature, ale ne z main.
Společný předek
Graf je slovník {commit: [rodiče]}. Napiš funkci spolecny_predek(graf, a, b), která vrátí nejbližšího společného předka commitů a a b (commit sám sebe počítá jako svého předka). Když žádný není, vrať None. Testované grafy mají jediné správné řešení.
def spolecny_predek(graf, a, b):
return None
Sloučení a konflikty
Práci z větve dostaneš zpátky třemi způsoby.
Výchozí stav merge rebase + fast-forward
A---B---C main A---B---C---M main A---B---C---D'---E' main
\ \ /
D---E feature D---Egit switch main
git merge feature/export # sloučení
git switch feature/export
git rebase main # přehraj moje commity na konec main- Fast-forward:
mainse od odbočení nepohnul, takže se ukazatel jen posune dopředu. - Merge commit: nový commit se dvěma rodiči. Historie zůstane, jak opravdu vznikla.
- Rebase: tvoje commity se znovu vytvoří nad novým základem. Historie je rovná, ale commity mají nové otisky.
Sloučení je trojcestné. Git nesrovnává jen dvě verze, ale obě se společným předkem. Tak pozná, kdo co změnil. Konflikt nastane, jen když obě strany změnily totéž na něco jiného.
def sluc(zaklad, nase, jejich):
vysledek, konflikty = {}, []
for klic in sorted(zaklad.keys() | nase.keys() | jejich.keys()):
z, n, j = zaklad.get(klic), nase.get(klic), jejich.get(klic)
if n == j:
hodnota = n
elif n == z:
hodnota = j
elif j == z:
hodnota = n
else:
konflikty.append(klic)
continue
if hodnota is not None:
vysledek[klic] = hodnota
return vysledek, konflikty
zaklad = {"port": 80, "debug": False, "barva": "bílá", "stary": 1}
nase = {"port": 8080, "debug": False, "barva": "černá", "stary": 1}
jejich = {"port": 80, "debug": True, "barva": "šedá"}
vysledek, konflikty = sluc(zaklad, nase, jejich)
print(vysledek)
print("konflikty:", konflikty)
{'debug': True, 'port': 8080}
konflikty: ['barva']port změnila jen naše strana, debug jen jejich a stary jejich strana smazala. To Git vyřeší sám. U barva se rozhodnout nedá a musí to udělat člověk. V souboru pak uvidíš značky:
<<<<<<< HEAD
barva = "černá"
=======
barva = "šedá"
>>>>>>> feature/exportMezi <<<<<<< a ======= je tvoje strana, pod ní příchozí. Konflikt není chyba ani havárie. Git se jen ptá.
git status # které soubory jsou v konfliktu (UU)
# otevři soubor, nech správný obsah a smaž všechny značky
git add nastaveni.py
git commit # dokončí merge
# při rebase místo toho: git rebase --continue
git merge --abort # rozmyslel sis to? návrat před merge
git rebase --abort # totéž pro rebaseCo se stane s otisky commitů D a E po git rebase main?
Rodič je součástí obsahu commitu. Jiný rodič znamená jiný obsah, a tedy jiný otisk.
Kdy při sloučení vznikne konflikt?
Změny v různých částech souboru Git spojí sám. Teprve překrývající se a odlišné úpravy vyžadují člověka.
Práce v týmu
Remote je kopie repozitáře jinde, typicky na GitHubu nebo GitLabu. Výchozí se jmenuje origin. Git přitom pracuje lokálně a se serverem mluví jen v těchto příkazech:
git clone https://github.com/firma/rozpocet.git # stáhni celý projekt
git fetch origin # stáhni novinky, nic neměň
git pull --ff-only # stáhni a posuň aktuální větev
git push -u origin feature/export # pošli větev na serverorigin/main je tvoje lokální poznámka, kde byl main na serveru při posledním fetch. Proto ti Git může tvrdit, že jsi aktuální, i když kolega právě něco poslal.
Běžný den v týmu vypadá takhle:
git switch main
git pull --ff-only
git switch -c fix/zaokrouhleni-dph
# práce, testy, malé commity
git add -p
git commit -m "fix(faktury): zaokrouhluj DPH na haléře"
git push -u origin fix/zaokrouhleni-dph
# na GitHubu otevři pull request, projde CI a kolega ho zkontroluje
# mezitím se pohnul main
git fetch origin
git rebase origin/main
git push --force-with-leasePull request (na GitLabu merge request) je žádost o začlenění větve. Kolem něj se odehrává review a běží automatické kontroly z lekce Ruff, mypy a pre-commit. Větev main bývá chráněná: přímý push je zakázaný a sloučit jde až po schválení a zelených testech.
Dobrý commit dělá jednu věc a zpráva vysvětluje hlavně proč. Rozšířená konvence Conventional Commits přidává strojově čitelný začátek:
fix(faktury): zaokrouhluj DPH na haléře
Součet po řádcích se lišil od součtu na faktuře o haléř
a účetní systém doklad odmítal.
Closes #142Rozeber zprávu commitu
Napiš funkci rozeber(zprava). Z prvního řádku ve tvaru typ(oblast)!: popis vrátí slovník s klíči typ, oblast, zlom a popis. Oblast je nepovinná (když chybí, je None). Vykřičník je nepovinný a znamená zlom = True, jinak False. Za dvojtečkou musí být mezera a neprázdný popis. Typ tvoří malá písmena. Když zpráva tvar nemá, vrať None.
import re
def rozeber(zprava):
prvni_radek = zprava.split("\n")[0]
return None
Do repozitáře nepatří nic, co jde vygenerovat, ani nic tajného. Soubor .gitignore to vyřadí:
__pycache__/
*.py[cod]
.venv/
dist/
*.egg-info/
.env
.mypy_cache/
.ruff_cache/
.pytest_cache/
.coveragePod kapotou · strategie větvení bez dogmat
Trunk-based development znamená krátké větve (hodiny až dny), časté slučování do main a nehotové funkce schované za feature flagy. Dobře se snáší s průběžným nasazováním a minimalizuje konflikty. Git Flow s větvemi develop a release/* má smysl hlavně tam, kde paralelně udržuješ víc vydaných verzí. U webové služby většinou přidává jen čekání.
Způsob slučování ovlivňuje další práci. Squash dá čistý main, kde jeden commit odpovídá jednomu PR, a snadný git revert, ale ztratí se mezikroky a závislé větve po něm potřebují rebase. Merge commit zachová realitu. Rebase merge dá rovnou historii s plnými detaily, takže vyžaduje disciplínu v jednotlivých commitech.
Užitečné a málo známé:
git config --global merge.conflictStyle zdiff3ukáže v konfliktu i společného předka. Řešení je pak mnohem snazší (od Gitu 2.35).git config --global rerere.enabled truesi pamatuje vyřešené konflikty a při opakovaném rebase je použije znovu.git commit --fixup=abc123a potomgit rebase -i --autosquash mainzapracuje připomínky do správného commitu.git rebase --update-refspři práci se závislými větvemi posune i ty ležící mezi commity (od 2.38).git worktree add ../hotfix maindá druhou pracovní složku bez nového klonu, takže nemusíš schovávat rozdělanou práci.git clone --filter=blob:nonestáhne obsah souborů až podle potřeby. U velkých monorepozitářů to dělá obrovský rozdíl.- Výchozí strategie slučování je od Gitu 2.34
ort, která nahradilarecursive.
Když se něco pokazí
Commitnutá práce se v Gitu ztrácí těžko. Nejdřív si ujasni, kde je chyba, a zvol nejmírnější nástroj.
| Situace | Příkaz |
|---|---|
| Zahodit neuložené změny v souboru | git restore app.py |
| Vrátit soubor z přípravny | git restore --staged app.py |
| Opravit poslední commit (ještě neodeslaný) | git commit --amend |
| Zrušit commit, ale nechat změny připravené | git reset --soft HEAD~1 |
| Zrušit commit, změny nechat v souborech | git reset HEAD~1 |
| Zahodit commit i změny | git reset --hard HEAD~1 |
| Vrátit commit, který už je na serveru | git revert abc123 |
| Odložit rozdělanou práci | git stash, později git stash pop |
| Najít ztracený commit | git reflog |
Rozdíl mezi reset a revert je zásadní. reset posouvá větev zpátky a přepisuje dějiny, takže patří jen na lokální práci. revert vytvoří nový commit s opačnou změnou a je bezpečný i na sdíleném main.
Reflog je deník všeho, kam se HEAD pohnul. Zachrání tě i po špatném reset --hard.
git reset --hard HEAD~3 # ajaj
git reflog # najdi řádek před katastrofou
git reset --hard HEAD@{1} # a vrať seKdyž něco přestalo fungovat a nevíš kdy, pomůže git bisect. Půlením historie najde commit, který chybu přinesl. Princip je binární vyhledávání:
commity = [f"c{i:04}" for i in range(1, 1025)]
PRVNI_SPATNY = "c0731"
def test_prosel(commit):
return commit < PRVNI_SPATNY
dobry, spatny = -1, len(commity) - 1
kroky = 0
while spatny - dobry > 1:
stred = (dobry + spatny) // 2
kroky += 1
if test_prosel(commity[stred]):
dobry = stred
else:
spatny = stred
print("viník:", commity[spatny])
print("počet testů:", kroky, "z", len(commity), "commitů")
viník: c0731 počet testů: 10 z 1024 commitů
git bisect start
git bisect bad # aktuální verze je rozbitá
git bisect good v1.4.0 # tahle ještě fungovala
git bisect run pytest tests/test_faktury.py # Git to dohledá sám
git bisect reset # návrat, kde jsi bylCommit s chybou už je na sdíleném main. Co je správně?
revert přidá opravný commit a nikomu nepřepíše historii. Force push na sdílenou větev by rozbil práci ostatním.
Pod kapotou · co reflog neuloží a jak hledat v historii
Reflog je lokální a záznamy po čase mizí (ve výchozím stavu 90 dní, u nedosažitelných commitů 30 dní). Neuloží nic, co nikdy nebylo v Gitu. Soubory změněné, ale nepřidané, po reset --hard nebo restore nevrátí nic. Pokud byla změna aspoň v přípravně, blob existuje a najde ho git fsck --lost-found.
Revert sloučovacího commitu potřebuje určit hlavní linii: git revert -m 1 <merge>. Pozor na návrat: Git si pamatuje, že commity z větve už v historii jsou, takže opakované sloučení téže větve nic nepřinese, dokud neuděláš revert revertu.
Forenzní nástroje: git log -S"nazev_funkce" najde commity, které změnily počet výskytů textu. git log -G"regex" hledá v řádcích diffu. git log -L :funkce:soubor.py ukáže historii jedné funkce. git blame -w -C -C ignoruje mezery a sleduje přesuny kódu mezi soubory. git range-diff porovná dvě verze téže větve před a po rebase, což v review ušetří spoustu času.
Odstranění dat z celé historie dělej přes git filter-repo (samostatný nástroj doporučený místo filter-branch). Mění všechny následující otisky, takže si všichni musí repozitář znovu naklonovat.
Vyzkoušej si: Git v obrázku
Tlačítky vytvářej commity a větve, přepínej se, slučuj a přeskládávej. Graf commitů se překresluje živě.