0 dní v řadě · 0 bodů

Profesionální vývoj · 40 min

Git a práce v týmu

Commity, větve, sloučení a konflikty, spolupráce přes pull requesty a záchrana po chybě. Včetně toho, jak Git ukládá data uvnitř.

Hloubka
Úkoly
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.

bash
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 init

Soubor neputuje do historie sám. Prochází třemi místy:

text
 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í.

bash
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 historie

Co 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"))
Výstup
36a0e7cf17ffe584221529d45113d821e70764a9
2de7c0609e3ec3fce247348848749f8369805d39

Výsledek odpovídá příkazu git hash-object, který dělá totéž:

bash
printf 'ahoj\n' | git hash-object --stdin

Objekty 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"))
Výstup
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.
Úkol

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()
Výstup
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íš.

bash
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 graf
text
A---B---C      main
     \
      D---E    feature/export  <- HEAD

Historie 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)
Výstup
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.

Úkol

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
Výstup

Sloučení a konflikty

Práci z větve dostaneš zpátky třemi způsoby.

text
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---E
bash
git switch main
git merge feature/export         # sloučení

git switch feature/export
git rebase main                  # přehraj moje commity na konec main
  • Fast-forward: main se 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)
Výstup
{'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:

text
<<<<<<< HEAD
barva = "černá"
=======
barva = "šedá"
>>>>>>> feature/export

Mezi <<<<<<< a ======= je tvoje strana, pod ní příchozí. Konflikt není chyba ani havárie. Git se jen ptá.

bash
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 rebase
Kvíz

Co se stane s otisky commitů D a E po git rebase main?

Kvíz

Kdy při sloučení vznikne konflikt?

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:

bash
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 server

origin/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:

bash
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-lease

Pull 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:

text
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 #142
Úkol

Rozeber 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
Výstup

Do repozitáře nepatří nic, co jde vygenerovat, ani nic tajného. Soubor .gitignore to vyřadí:

text
__pycache__/
*.py[cod]
.venv/
dist/
*.egg-info/
.env
.mypy_cache/
.ruff_cache/
.pytest_cache/
.coverage
Pod 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 zdiff3 ukáže v konfliktu i společného předka. Řešení je pak mnohem snazší (od Gitu 2.35).
  • git config --global rerere.enabled true si pamatuje vyřešené konflikty a při opakovaném rebase je použije znovu.
  • git commit --fixup=abc123 a potom git rebase -i --autosquash main zapracuje připomínky do správného commitu.
  • git rebase --update-refs při práci se závislými větvemi posune i ty ležící mezi commity (od 2.38).
  • git worktree add ../hotfix main dá druhou pracovní složku bez nového klonu, takže nemusíš schovávat rozdělanou práci.
  • git clone --filter=blob:none stá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á nahradila recursive.

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.

SituacePříkaz
Zahodit neuložené změny v souborugit restore app.py
Vrátit soubor z přípravnygit 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 souborechgit reset HEAD~1
Zahodit commit i změnygit reset --hard HEAD~1
Vrátit commit, který už je na serverugit revert abc123
Odložit rozdělanou prácigit stash, později git stash pop
Najít ztracený commitgit 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.

bash
git reset --hard HEAD~3     # ajaj
git reflog                  # najdi řádek před katastrofou
git reset --hard HEAD@{1}   # a vrať se

Když 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ů")
Výstup
viník: c0731
počet testů: 10 z 1024 commitů
bash
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 byl
Kvíz

Commit s chybou už je na sdíleném main. Co je správně?

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ě.