Hogyan működik a Git belsőleg?

Question

Accepted Answer

Belsőleg a Git egy **tartalom-indexelhető objektumtár** — mindent **objektumként** tárol (blobok, fák, commitok, címkék), amelyeket **SHA-1 kivonatuk** azonosít. Ennek a modellnek az megértése demisztifikálja a Gitet és megmagyarázza, hogy miért viselkednek az operációi az adott módon.

## A Git egy tartalom-indexelhető objektumtár

```text
Git stores 4 types of OBJECTS, each identified by the SHA-1 HASH of its content:
  BLOB   → file CONTENTS (just the data, no filename)
  TREE   → a directory: maps names → blobs (files) and trees (subdirs) + permissions
  COMMIT → a snapshot: points to a TREE (the root) + parent commit(s) + author/message
  TAG    → an annotated tag object (points to a commit, with metadata)
→ Content-addressable: an object's ID IS the hash of its content (same content = same hash).
```

## A commit egy pillanatkép, nem egy diff

```text
→ Each COMMIT points to a complete TREE (the full state of the project at that point)
→ Git stores SNAPSHOTS, not diffs (though it compresses/deduplicates internally):
  unchanged files → the commit's tree just REUSES the same blob (same hash) → efficient
→ Diffs you see are COMPUTED between snapshots, not stored.
```

## Hogyan illeszkedik össze

```text
Branch (e.g. main) → a pointer (a ref) to a COMMIT
HEAD → points to the current branch (or commit)
Commit → tree → blobs (the snapshot)
Commit → parent → parent → ... (the history chain)
→ Branches/tags are just small files containing a commit hash (cheap pointers).
  That's WHY branching is so lightweight.
```

## Miért magyarázza ez meg a Git viselkedését

```text
✓ Branches are cheap → they're just a 40-char hash in a file (not file copies)
✓ Integrity → content-addressing means corruption/changes are detectable (hash mismatch)
✓ Commits are immutable → changing anything = a new hash = a new commit (why rebase
  creates NEW commits, why history rewriting changes hashes)
✓ Deduplication → identical content stored once (shared blobs)
```

## Miért számít

A Git belső működésének megértése értékes senior szintű tudás, mert **demisztifikálja a Gitet** és megmagyarázza, hogy *miért* viselkednek az operációi az adott módon, mélyítve az meg a Git magabiztos alkalmazásáról és használatáról való érvelés képességét.

Az alapvető modell — a Git mint **tartalom-indexelhető objektumtár** négy objektumtípussal (blobok a fájl tartalmához, fák a könyvtárakhoz, commitok a pillanatképekhez, címkék), mindegyik azonosítva a **tartalmának kivonatával** — az alapja mindannak, ami erre épül.

Annak megértése, hogy **a commit egy pillanatkép, nem egy diff** (minden commit egy teljes fát mutat, amely a projekt teljes állapotát reprezentálja, a változatlan fájlok hatékonyan felhasználják az ugyanazokat a blobokat, és a diffokat inkább kiszámítják, mint tárolják) korrigál egy gyakori félreértést és magyarázza a Git pillanatkép-alapú modelljét.

Annak látása, hogy **hogyan illeszkedik össze** (ágak és címkék mint olcsó mutatók/referenciák a commitokhoz, HEAD az aktuális ágra mutat, commitok szülőkön keresztüli láncolása) felfedi az alatti elegáns egyszerűséget.

A legértékesebben, ez a megértés **megmagyarázza a Git megfigyelhető viselkedését**: miért **könnyűek az ágak** (csak egy kivonat egy kis fájlban, nem fájlmásolatok — megmagyarázza, hogy az ágzás miért olyan gyors), miért van a Gitnek **integritása** (tartalom-indexelés detektálja a korrupciót a kivonat eltérésén keresztül), miért **nem változtathatók a commitok** és az olyan történet-átírási operációk, mint a rebase új commitokat hoznak létre új kivonatokkal (bármilyen tartalom megváltozása megváltoztatja a kivonatot), és miért **deduplikál** a Git (az azonos tartalom egyszer tárolódik).

Ez a mélyebb modell a Gitet egy memorizált parancsok halmazából egy érthető rendszerré alakítja át, lehetővé téve az összetett operációkról való magabiztos érvelést.

Mivel a belső objektummodell megértése megmagyarázza, hogy miért viselkedik a Git úgy ahogy (könnyű ágak, nem változtatható commitok, kivonat változása az átíráson, integritás), és senior szintre emeli az egyik Gitet használóból az igazi megértésig, a Git belső működésének megértése értékes senior szintű tudás — egy olyan téma, amely tükrözi a senior szerepekért elvárt mélységet, és biztosítja a mentális modellt a Git magabiztos érveléséhez, demisztifikálva annak viselkedését és az fejlett operációkat érthetővé téve az előtt, hogy titokzatos maradna.