Cos'è un file .gitignore e come si usa?

Question

Accepted Answer

Un file **.gitignore** dice a Git quali file e directory **ignorare** — non tracciarli nel controllo di versione. È usato per escludere file generati, dipendenze, segreti, e file specifici dell'ambiente che non dovrebbero essere committed.

## Cosa fa .gitignore

```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 ignora i file che corrispondono a questi pattern — non appariranno in `git status`, non saranno stagati, e non saranno committed.

## Sintassi dei pattern

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

## Cosa ignorare (categorie comuni)

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

## Perché è importante

Capire `.gitignore` è importante per **mantenere i repository puliti e sicuri**, quindi è conoscenza Git pratica essenziale.

Un file `.gitignore` esclude file che **non dovrebbero essere nel controllo di versione**, affrontando diverse esigenze reali.

Mantiene i repository puliti escludendo **file generati/derivati** (output di build, artefatti compilati) e **dipendenze** (`node_modules`, che sono enormi e reinstallate dai file manifest — committarli farebbe gonfiare il repo) — in modo che il repository contenga solo il codice sorgente significativo.

Esclude **file specifici dell'ambiente e personali** (spazzatura del SO come `.DS_Store`, configurazioni dell'editor) che inquinerebbero il repo e causerebbero rumore.

Ma soprattutto, è essenziale per la **sicurezza**: escludere **segreti** (file `.env`, credenziali, chiavi API) è vitale perché **committare segreti è un grave errore di sicurezza** — una volta committed, i segreti sono nella cronologia del repository (e potenzialmente pushati su repo remoti/pubblici dove possono essere sfruttati), quindi `.gitignore` è una difesa chiave contro il commit accidentale di dati sensibili.

Capire la **sintassi dei pattern** (directory, wildcard, negazione, root-relative) ti permette di scrivere regole di ignore efficaci, e conoscere l'importante avvertenza che **i file già tracciati devono essere detraccati** (`git rm --cached`) prima che `.gitignore` faccia effetto previene una confusione comune.

Poiché i repository puliti (senza file generati, dipendenze, o disordine) e soprattutto **non committare segreti** contano per la qualità e la sicurezza del repository, e poiché `.gitignore` è il meccanismo standard per escludere file che non dovrebbero essere tracciati, capire `.gitignore` — cosa ignorare (dipendenze, output di build, e criticamente segreti), la sintassi dei pattern, e l'avvertenza del detracking — è conoscenza Git essenziale e frequentemente applicata per mantenere repository puliti e sicuri, con l'aspetto della sicurezza nel mantener i segreti fuori dal controllo di versione che è particolarmente importante.