Hvordan fungerer Git internt?

Question

Accepted Answer

Internt er Git en **indholdsorienteret objektlagring** — det gemmer alt som **objekter** (blobs, træer, commits, tags) identificeret ved deres **SHA-1 hash**. At forstå denne model demystificerer Git og forklarer, hvorfor dens operationer opfører sig som de gør.

## Git er en indholdsorienteret objektlagring

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

## En commit er et øjebliksbillede, ikke en 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.
```

## Hvordan det passer sammen

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

## Hvorfor dette forklarer Gits opførsel

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

## Hvorfor det betyder noget

At forstå, hvordan Git fungerer internt, er værdifuld viden på seniorniveau, fordi det **demystificerer Git** og forklarer *hvorfor* dets operationer opfører sig som de gør, hvilket fordyber din evne til at tænke over og bruge Git med selvtillid.

Kernmodellen — Git som en **indholdsorienteret objektlagring** med fire objekttyper (blobs til filindhold, træer til mapper, commits til øjebliksbilleder, tags) hver identificeret af **hashen af dens indhold** — er det fundament, som alt andet bygger på.

At forstå, at **en commit er et øjebliksbillede, ikke en diff** (hver commit peger på et komplet træ, der repræsenterer projektets fulde tilstand, hvor uændrede filer effektivt genbruger samme blobs, og diffs beregnes snarere end gemmes) korrigerer en almindelig misforståelse og forklarer Gits øjebliksbillede-baserede model.

At se **hvordan det passer sammen** (grene og tags som billige pointere/refs til commits, HEAD peger på den aktuelle gren, commits kædet via forældre) afslører den elegante enkelhed bagved.

Mest værdifuldt forklarer denne forståelse **Gits observerbare opførsel**: hvorfor **grene er lette** (blot en hash i en lille fil, ikke filkopier — hvilket forklarer, hvorfor grening er så hurtig), hvorfor Git har **integritet** (indholdsorientering detekterer korruption via hash-uoverensstemmelser), hvorfor **commits er uforanderlige** og historieomskrivningsoperationer som rebase skaber **nye commits med nye hashes** (ændring af noget indhold ændrer hashen), og hvorfor Git **deduplicerer** (identisk indhold gemt én gang).

Denne dybere model transformerer Git fra et sæt af udenadslært kommandoer til et forståeligt system, hvilket muliggør sikker ræsonnering om komplekse operationer.

Fordi at forstå den interne objektmodel forklarer, hvorfor Git opfører sig som det gør (lette grene, uforanderlige commits, hashændringer ved omskrivning, integritet), og fordi det løfter én fra at bruge Git til virkelig at forstå det, er forståelse af Gits interne arbejde værdifuld viden på seniorniveau — et emne, der afspejler den dybde, der forventes for seniorroller, og som leverer den mentale model til at ræsonnere om Git med selvtillid, demystificerer dets opførsel og gør avancerede operationer forståelige snarere end mystiske.