Cum funcționează Git la nivel intern?

Question

Accepted Answer

La nivel intern, Git este un **object store adresabil după conținut** — stochează totul sub formă de **obiecte** (blobs, trees, commits, tags) identificate prin **hash SHA-1**. Înțelegerea acestui model demistifică Git și explică de ce operațiile sale se comportă în anumite moduri.

## Git este un object store adresabil după conținut

```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).
```

## Un commit este o snapshot, nu un 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.
```

## Cum se încadrează totul

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

## De ce aceasta explică comportamentul Git

```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)
```

## De ce contează

Înțelegerea modului în care Git funcționează la nivel intern este cunoaștere valoroasă de nivel senior, deoarece **demistifică Git** și explică *de ce* operațiile sale se comportă în anumite moduri, adâncindu-ți capacitatea de a raționa despre Git și de a-l folosi cu încredere.

Modelul core — Git ca **object store adresabil după conținut** cu patru tipuri de obiecte (blobs pentru conținut de fișiere, trees pentru directoare, commits pentru snapshots, tags) fiecare identificat prin **hash-ul conținutului său** — este fundația pe care se sprijină totul.

Înțelegerea că **un commit este o snapshot, nu un diff** (fiecare commit se referă la un arbore complet reprezentând starea completă a proiectului, cu fișiere nemodificate reutilizând eficient aceleași blobs, iar diff-urile sunt calculate mai degrabă decât stocate) corectează o concepție greșită comună și explică modelul bazat pe snapshots al Git.

Vederea **modului în care se încadrează totul** (branches și tags ca pointeri/refs ieftini la commits, HEAD indicând branch-ul curent, commits conectate prin parents) relevă simplitatea elegantă din spatele scenei.

Cel mai valoros, această înțelegere **explică comportamentul observabil al Git**: de ce **branches sunt ușoare** (doar un hash într-un fișier mic, nu copii de fișiere — explicând de ce branching este atât de rapid), de ce Git are **integritate** (adresarea după conținut detectează corupția prin nepotriviri de hash), de ce **commits sunt imuabile** și operațiile de rescrierea a istoricului precum rebase creează **noi commits cu noi hash-uri** (schimbarea oricărui conținut schimbă hash-ul), și de ce Git **deduplicează** (conținutul identic stocat o singură dată).

Acest model mai profund transformă Git dintr-un set de comenzi memorate într-un sistem înțeles, permițând raționament încrezător despre operațiuni complexe.

Deoarece înțelegerea modelului intern al obiectelor explică de ce Git se comportă cum se comportă (branches ușoare, commits imuabile, schimbări de hash la rescrierea istoricului, integritate) și te elevează de la folosirea Git la înțelegerea adevărată a acestuia, înțelegerea internelor Git este cunoaștere valoroasă de nivel senior — o temă care reflectă profunzimea așteptată pentru roluri senior și oferă modelul mental pentru a raționa despre Git cu încredere, demistificând comportamentul acestuia și făcând operațiunile avansate înțelese mai degrabă decât misterioase.