Wie funktioniert Git intern?

Question

Accepted Answer

Intern ist Git ein **inhaltsadressierbarer Objektspeicher** — es speichert alles als **Objekte** (Blobs, Trees, Commits, Tags), die durch ihren **SHA-1-Hash** identifiziert werden. Das Verstehen dieses Modells demystifiziert Git und erklärt, warum seine Operationen sich so verhalten, wie sie es tun.

## Git ist ein inhaltsadressierbarer Objektspeicher

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

## Ein Commit ist ein Snapshot, kein 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.
```

## Wie es zusammenpasst

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

## Warum dies Gits Verhalten erklärt

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

## Warum es wichtig ist

Das Verstehen, wie Git intern funktioniert, ist wertvolles Know-how auf Senior-Level, weil es **Git demystifiziert** und erklärt, *warum* seine Operationen sich so verhalten, wie sie es tun, und vertieft deine Fähigkeit, Git selbstbewusst zu verstehen und zu nutzen.

Das Kernmodell — Git als **inhaltsadressierbarer Objektspeicher** mit vier Objekttypen (Blobs für Dateiinhalte, Trees für Verzeichnisse, Commits für Snapshots, Tags) — jeweils identifiziert durch den **Hash seines Inhalts** — ist die Grundlage, auf der alles andere aufbaut.

Das Verständnis, dass **ein Commit ein Snapshot ist, kein Diff** (jeder Commit zeigt auf einen kompletten Tree, der den vollständigen Projektzustand repräsentiert, wobei unveränderte Dateien effizient dieselben Blobs wiederverwenden, und Diffs berechnet statt gespeichert werden), korrigiert ein weit verbreitetes Missverständnis und erklärt Gits Snapshot-basiertes Modell.

Das Sehen, **wie es zusammenpasst** (Branches und Tags als günstige Pointer/Refs zu Commits, HEAD zeigt auf den aktuellen Branch, Commits sind über Parents verkettet), offenbart die elegante Einfachheit darunter.

Am wertvollsten ist dieses Verständnis, das **Gits beobachtbares Verhalten erklärt**: warum **Branches leichtgewichtig sind** (nur ein Hash in einer kleinen Datei, keine Dateikopien — erklärt, warum Branching so schnell ist), warum Git **Integrität** hat (inhaltsadressierung erkennt Beschädigungen durch Hash-Unstimmigkeiten), warum **Commits unveränderlich sind** und History-Rewriting-Operationen wie Rebase **neue Commits mit neuen Hashes erstellen** (Änderung von Inhalten ändert den Hash), und warum Git **dedupliziert** (identischer Inhalt wird einmal gespeichert).

Dieses tiefere Modell transformiert Git von einer Reihe auswendig gelernter Befehle in ein verständliches System, das sicheres Denken über komplexe Operationen ermöglicht.

Da das Verstehen des internen Objektmodells erklärt, warum Git sich so verhält, wie es sich verhält (leichtgewichtige Branches, unveränderliche Commits, Hash-Änderungen beim Rewriting, Integrität), und einen vom Verwenden von Git zum wirklichen Verstehen erhebt, ist das Verstehen von Git-Interna wertvolles Senior-Level-Know-how — ein Thema, das die Tiefe widerspiegelt, die für Senior-Positionen erwartet wird, und das mentale Modell bietet, um Git selbstbewusst zu verstehen, sein Verhalten zu demystifizieren und fortgeschrittene Operationen verständlich zu machen, statt sie geheimnisvoll zu lassen.