Hvad er en .gitignore-fil, og hvordan bruger du den?

Question

Accepted Answer

En **.gitignore**-fil fortæller Git, hvilke filer og mapper der skal **ignoreres** — ikke spores i versionskontrol. Den bruges til at udelukke genererede filer, afhængigheder, hemmeligheder og miljøspecifikke filer, som ikke bør committes.

## Hvad .gitignore gør

```text
# .gitignore — patterns of files Git should NOT track
node_modules/          # dependencies (reinstalled from package files, don't commit)
dist/                  # build output (generated, don't commit)
*.log                  # log files
.env                   # ⚠️ SECRETS / environment variables — NEVER commit!
.DS_Store              # OS-specific junk
.vscode/               # editor config (often personal)
build/
coverage/
*.tmp
```

Git ignorerer filer, der matcher disse mønstre — de vises ikke i `git status`, vil ikke blive staged, og vil ikke blive committed.

## Mønstersyntaks

```text
node_modules/    → ignore a directory (and everything in it)
*.log            → ignore all files with a .log extension
!important.log   → EXCEPTION: do NOT ignore this (negation)
/build           → ignore "build" only in the root (leading slash = root-relative)
doc/*.txt        → .txt files in doc/ but not subdirectories
**/temp          → "temp" anywhere in the tree
```

## Hvad skal ignoreres (almindelige kategorier)

```text
✓ DEPENDENCIES — node_modules/, vendor/ (reinstalled from manifests; huge, don't commit)
✓ BUILD OUTPUT — dist/, build/, *.o (generated from source)
✓ SECRETS — .env, credentials, keys (⚠️ NEVER commit secrets — a serious security issue)
✓ ENVIRONMENT/OS/EDITOR files — .DS_Store, .idea/, .vscode/ (personal/machine-specific)
✓ LOGS, caches, temp files
```

```text
⚠️ Already-tracked files aren't ignored by adding them later — untrack first:
   git rm --cached <file>   (then commit; .gitignore prevents re-adding)
```

## Hvorfor det betyder noget

At forstå `.gitignore` er vigtigt for at **holde repositories rene og sikre**, så det er væsentlig praktisk Git-viden.

En `.gitignore`-fil udelukker filer, der **ikke bør være i versionskontrol**, og løser flere praktiske behov.

Den holder repositories rene ved at udelukke **genererede/afledte filer** (build-output, kompilerede artefakter) og **afhængigheder** (`node_modules`, som er enorme og genskabes fra manifest-filer — hvis man committede dem, ville det oppuste repositoryet) — så repositoryet indeholder kun den meningsfulde kildekode.

Den udelukker **miljøspecifikke og personlige filer** (OS-skrald som `.DS_Store`, editor-konfigurationer), som ville fylde repositoryet og forårsage støj.

Mest kritisk er det **sikkerhed**: udelukkelse af **hemmeligheder** (`.env`-filer, legitimationsoplysninger, API-nøgler) er vital, fordi **committing af hemmeligheder er en alvorlig sikkerhedsfejl** — når de er committed, er hemmeligheder i repositoryets historie (og potentielt pushed til remote/offentlige repositories, hvor de kan udnyttes), så `.gitignore` er en vigtig forsvar mod utilsigtet committing af følsomme data.

Forståelse af **mønstersyntaksen** (mapper, jokertegn, negation, rod-relativ) giver dig mulighed for at skrive effektive ignoreringsregler, og kendskab til den vigtige gotcha, at **allerede sporede filer skal stoppes med at blive sporet** (`git rm --cached`), før `.gitignore` træder i kraft, forebygger en almindelig forvirring.

Da rene repositories (uden genererede filer, afhængigheder eller uorden) og især **ikke committing af hemmeligheder** betyder noget for repository-kvalitet og sikkerhed, og da `.gitignore` er standardmekanismen til at udelukke filer, der ikke skal spores, er forståelse af `.gitignore` — hvad der skal ignoreres (afhængigheder, build-output og kritisk hemmeligheder), mønstersyntaksen og gotchaen med at stoppe sporing — væsentlig, ofte anvendt Git-viden til at vedligeholde rene, sikre repositories, hvor sikkerhedsaspektet ved at holde hemmeligheder uden for versionskontrol er særligt vigtig.