Hvordan fungerer Git internt?

Question

Accepted Answer

Internt er Git et **innholdsadresserbart objektlager** — det lagrer alt som **objekter** (blobs, trees, commits, tags) identifisert ved deres **SHA-1 hash**. Å forstå denne modellen demystifiserer Git og forklarer hvorfor dets operasjoner oppfører seg som de gjør.

## Git er et innholdsadresserbart objektlager

```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 øyeblikksbilde, 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 henger 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 oppfø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 betyr noe

Å forstå hvordan Git fungerer internt er verdifull seniortnivå-kunnskap fordi det **demystifiserer Git** og forklarer *hvorfor* dets operasjoner oppfører seg som de gjør, og utdyper din evne til å resonnere om og bruke Git selvsikkert.

Kjernmodellen — Git som et **innholdsadresserbart objektlager** med fire objekttyper (blobs for filinnhold, trees for kataloger, commits for øyeblikksbilder, tags) hver identifisert ved **hashen av sitt innhold** — er grunnlaget som alt annet hviler på.

Å forstå at **en commit er et øyeblikksbilde, ikke en diff** (hver commit peker til et komplett tre som representerer prosjektets fulle tilstand, med uendrede filer som effektivt gjenbruker de samme blobene, og diffs beregnet i stedet for lagret) korrigerer en vanlig misforståelse og forklarer Gits øyeblikksbildebaserte modell.

Å se **hvordan det henger sammen** (branches og tags som billige pekere/refs til commits, HEAD peker til gjeldende branch, commits kjeder via foreldre) avslører den elegante enkelheten under overflaten.

Mest verdifullt forklarer denne forståelsen **Gits observerbare oppførsel**: hvorfor **branches er lette** (bare en hash i en liten fil, ikke filkopier — forklarer hvorfor branching er så raskt), hvorfor Git har **integritet** (innholdsadressering oppdager korrupsjon via hash-mismatcher), hvorfor **commits er uforanderlige** og historiereskrivingsoperasjoner som rebase lager **nye commits med nye hasher** (endring av innhold endrer hashen), og hvorfor Git **deduplicerer** (identisk innhold lagret en gang).

Denne dypere modellen transformerer Git fra et sett med memorerte kommandoer til et forståelig system, og muliggjør sikker resonnering om komplekse operasjoner.

Siden å forstå den interne objektmodellen forklarer hvorfor Git oppfører seg som det gjør (lette branches, uforanderlige commits, hash-endringer ved omskriving, integritet) og løfter en fra å bruke Git til virkelig å forstå det, er det verdifull seniortnivå-kunnskap å forstå Git-internals — et emne som reflekterer dybden som forventes for seniorroller og gir den mentale modellen til å resonnere om Git selvsikkert, demystifisere dets oppførsel og gjøre avanserte operasjoner forståelige i stedet for mystiske.