¿Qué es un archivo .gitignore y cómo lo usas?

Question

Accepted Answer

Un archivo **.gitignore** le indica a Git qué archivos y directorios **ignorar** — no rastrear en el control de versiones. Se utiliza para excluir archivos generados, dependencias, secretos y archivos específicos del entorno que no deberían confirmarse.

## Qué hace .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 los archivos que coinciden con estos patrones — no aparecerán en `git status`, no se organizarán y no se confirmarán.

## Sintaxis de patrones

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

## Qué ignorar (categorías comunes)

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

## Por qué es importante

Comprender `.gitignore` es importante para **mantener los repositorios limpios y seguros**, por lo que es un conocimiento esencial y práctico de Git.

Un archivo `.gitignore` excluye archivos que **no deberían estar en el control de versiones**, abordando varias necesidades reales.

Mantiene los repositorios limpios al excluir **archivos generados/derivados** (salida de compilación, artefactos compilados) y **dependencias** (`node_modules`, que son enormes y se reinstalan desde archivos de manifiesto — confirmarlos inflaría el repositorio) — por lo que el repositorio contiene solo el código fuente significativo.

Excluye **archivos específicos del entorno y personales** (basura del sistema operativo como `.DS_Store`, configuraciones de editor) que desordenarían el repositorio y causarían ruido.

Más críticamente, es esencial para la **seguridad**: excluir **secretos** (archivos `.env`, credenciales, claves API) es vital porque **confirmar secretos es un grave error de seguridad** — una vez confirmados, los secretos están en el historial del repositorio (y potencialmente enviados a repositorios remotos/públicos donde pueden ser explotados), por lo que `.gitignore` es una defensa clave contra confirmar accidentalmente datos sensibles.

Comprender la **sintaxis de patrones** (directorios, comodines, negación, raíz relativa) te permite escribir reglas de ignora efectivas, y saber el detalle importante de que **los archivos ya rastreados deben dejarase de rastrear** (`git rm --cached`) antes de que `.gitignore` tenga efecto previene una confusión común.

Ya que los repositorios limpios (sin archivos generados, dependencias o desorden) y especialmente **no confirmar secretos** importan para la calidad del repositorio y la seguridad, y ya que `.gitignore` es el mecanismo estándar para excluir archivos que no deben rastrearse, comprender `.gitignore` — qué ignorar (dependencias, salida de compilación y críticamente secretos), la sintaxis de patrones y el detalle de dejar de rastrear — es un conocimiento esencial y frecuentemente aplicado de Git para mantener repositorios limpios y seguros, siendo el aspecto de seguridad de mantener secretos fuera del control de versiones particularmente importante.