Vad är en .gitignore-fil och hur använder du den?

Question

Accepted Answer

En **.gitignore**-fil talar om för Git vilka filer och kataloger som ska **ignoreras** — inte spåras i versionskontroll. Den används för att exkludera genererade filer, beroenden, hemligheter och miljöspecifika filer som inte bör committas.

## Vad .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 ignorerar filer som matchar dessa mönster — de kommer inte att visas i `git status`, kommer inte att mellanlagras och kommer inte att committas.

## Mönstersyntax

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

## Vad man ska ignorera (vanliga 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)
```

## Varför det är viktigt

Att förstå `.gitignore` är viktigt för att **hålla repositories rena och säkra**, så det är viktig praktisk Git-kunskap.

En `.gitignore`-fil exkluderar filer som **inte bör finnas i versionskontroll**, och löser flera verkliga behov.

Den håller repositories rena genom att exkludera **genererade/härledda filer** (byggutdata, kompilerade artefakter) och **beroenden** (`node_modules`, som är enorma och återinstalleras från manifestfiler — att commita dem skulle fylla upp repot) — så repot innehåller endast meningsfull källkod.

Den exkluderar **miljöspecifika och personliga filer** (operativsystemskräp som `.DS_Store`, redigeringskonfigurationer) som skulle göra repot orörigt och orsaka brus.

Mest kritiskt är det **säkerhet**: exkludering av **hemligheter** (`.env`-filer, autentiseringsuppgifter, API-nycklar) är vital eftersom **att commita hemligheter är ett allvarligt säkerhetsmissöde** — när de väl är committade finns de i repositorgets historia (och potentiellt pushade till fjärr-/offentliga repos där de kan exploateras), så `.gitignore` är ett viktigt försvar mot att av misstag commita känslig data.

Att förstå **mönstersyntaxen** (kataloger, jokertecken, negation, rotrelativ) låter dig skriva effektiva ignoreringskällor, och att veta den viktiga gotchan att **redan spårade filer måste vara ospårade** (`git rm --cached`) innan `.gitignore` träder i kraft förhindrar förvirring.

Since rena repositories (inga genererade filer, beroenden eller skräp) och speciellt **att inte commita hemligheter** är viktigt för repositorykvalitet och säkerhet, och eftersom `.gitignore` är standardmekanismen för att exkludera filer som inte bör spåras, är det essentiellt att förstå `.gitignore` — vad man ska ignorera (beroenden, byggutdata och kritiskt hemligheter), mönstersyntaxen och ospårningsgotchan — väsentlig, ofta använd Git-kunskap för att upprätthålla rena, säkra repositories, med säkerhetaspekten att hålla hemligheter utanför versionskontroll särskilt viktig.