Ignorar archivos con .gitignore

En cualquier proyecto de desarrollo, hay archivos que no deberían incluirse en el control de versiones. Estos pueden ser archivos temporales, dependencias externas, archivos de configuración local o información sensible como contraseñas y claves API. Git proporciona una solución elegante para este problema: el archivo .gitignore.

¿Qué es .gitignore?

El archivo .gitignore es un archivo de texto plano que le indica a Git qué archivos o directorios debe ignorar en un proyecto. Cuando Git encuentra un archivo listado en .gitignore, lo excluye del seguimiento, lo que significa que:

• No aparecerá en git status como archivo no rastreado
• No será añadido al staging area con comandos como git add .
• No será incluido en los commits

¿Por qué usar .gitignore?

Hay varias razones para excluir ciertos archivos del control de versiones:

1. Archivos generados automáticamente: Archivos de compilación, caches, logs
2. Dependencias externas: Paquetes que pueden ser reinstalados (node_modules, vendor)
3. Configuración local: Archivos con configuración específica de cada desarrollador
4. Información sensible: Contraseñas, tokens, claves API
5. Archivos temporales: Archivos de respaldo, archivos de sistema (.DS_Store, Thumbs.db)
6. Archivos grandes: Binarios, imágenes o videos que aumentarían innecesariamente el tamaño del repositorio

Creación del archivo .gitignore

Para crear un archivo .gitignore, simplemente crea un nuevo archivo de texto con ese nombre en la raíz de tu repositorio:

touch .gitignore  # En sistemas Unix/Linux/macOS
# o
echo > .gitignore  # En Windows

También puedes crearlo desde tu editor de código favorito.

Sintaxis de .gitignore

La sintaxis de .gitignore es bastante sencilla pero poderosa:

Reglas básicas

# Esto es un comentario

# Ignorar un archivo específico
archivo.txt

# Ignorar todos los archivos con una extensión
*.log

# Ignorar un directorio completo
node_modules/

# Ignorar todos los archivos en un directorio específico
logs/*

# Ignorar todos los archivos .txt en el directorio docs
docs/*.txt

Patrones avanzados

# Ignorar archivos en cualquier directorio llamado 'temp'
**/temp

# Ignorar archivos .txt en el directorio actual, pero no en subdirectorios
/*.txt

# Ignorar todos los archivos en un directorio excepto uno específico
logs/*
!logs/important.log

# Ignorar archivos que coincidan con un patrón
*~        # Archivos que terminan con ~
.[oa]     # Archivos que terminan con .o o .a

Caracteres especiales

• *: Coincide con cero o más caracteres
• ?: Coincide con un solo carácter
• [abc]: Coincide con uno de los caracteres listados
• [0-9]: Coincide con un rango de caracteres
• **: Coincide con directorios anidados (por ejemplo, a/**/z coincide con a/z, a/b/z, a/b/c/z, etc.)
• !: Niega un patrón (archivos que coinciden con el patrón no serán ignorados)

Ejemplos de .gitignore para diferentes proyectos

Para un proyecto Node.js

# Dependencias
node_modules/
npm-debug.log
yarn-error.log
yarn-debug.log

# Archivos de entorno
.env
.env.local
.env.development.local
.env.test.local
.env.production.local

# Directorios de compilación
/dist
/build

# Cobertura de pruebas
/coverage

# Archivos de sistema
.DS_Store
Thumbs.db

Para un proyecto Python

# Archivos de byte compilados
__pycache__/
*.py[cod]
*$py.class

# Distribución / empaquetado
dist/
build/
*.egg-info/

# Entornos virtuales
venv/
env/
ENV/

# Archivos de prueba y cobertura
.coverage
htmlcov/

# Jupyter Notebook
.ipynb_checkpoints

Para un proyecto Java/Maven

# Archivos compilados
*.class
target/

# Archivos de log
*.log

# Archivos de BlueJ
*.ctxt

# Archivos de Mobile Tools for Java (J2ME)
.mtj.tmp/

# Archivos de paquete
*.jar
*.war
*.ear

# Archivos de IDE
.idea/
*.iml
.classpath
.project
.settings/

Múltiples archivos .gitignore

Git permite tener múltiples archivos .gitignore en diferentes directorios del proyecto. Las reglas se aplican de manera recursiva a los directorios y subdirectorios:

• Un archivo .gitignore en la raíz del repositorio afecta a todo el proyecto
• Un archivo .gitignore en un subdirectorio afecta solo a ese directorio y sus subdirectorios

Esto permite tener reglas específicas para diferentes partes del proyecto.

.gitignore global

También puedes configurar un archivo .gitignore global que se aplique a todos tus repositorios:

git config --global core.excludesfile ~/.gitignore_global

Luego edita ~/.gitignore_global para añadir patrones que quieras ignorar en todos tus proyectos, como archivos específicos de tu editor o sistema operativo.

Ignorar archivos ya rastreados

El archivo .gitignore solo afecta a archivos no rastreados. Si un archivo ya está siendo rastreado por Git, añadirlo a .gitignore no lo excluirá del repositorio. Para dejar de rastrear un archivo ya incluido:

git rm --cached archivo.txt

Esto elimina el archivo del repositorio pero lo mantiene en tu sistema de archivos local.

Plantillas de .gitignore

GitHub mantiene un repositorio con plantillas de .gitignore para diferentes lenguajes y frameworks: github/gitignore.

También puedes generar un archivo .gitignore personalizado usando herramientas como:

• gitignore.io
• La opción "Add .gitignore" al crear un repositorio en GitHub

Depuración de problemas con .gitignore

Si un archivo que debería ser ignorado sigue apareciendo en git status, puedes depurar el problema:

git check-ignore -v archivo.txt

Este comando te mostrará qué regla (si hay alguna) está afectando al archivo.

Buenas prácticas

1. Crea el .gitignore al inicio del proyecto: Es más fácil que limpiar el repositorio después
2. Incluye el .gitignore en el repositorio: Así todos los colaboradores tendrán las mismas reglas
3. Sé específico: Evita patrones demasiado generales que puedan ignorar archivos importantes
4. Documenta las reglas complejas: Usa comentarios para explicar patrones no obvios
5. Nunca ignores archivos de configuración compartidos: Como .gitignore mismo o archivos de configuración del proyecto que todos deben usar
6. Usa .gitignore global para preferencias personales: Como archivos específicos de tu editor
7. Revisa periódicamente: Actualiza el .gitignore cuando cambien las dependencias o herramientas del proyecto

Conclusión

El archivo .gitignore es una herramienta fundamental para mantener tu repositorio Git limpio y eficiente. Al excluir archivos innecesarios o sensibles, reduces el tamaño del repositorio, evitas conflictos y mejoras la seguridad. Dedicar tiempo a configurar correctamente tu .gitignore al inicio de un proyecto ahorrará muchos problemas en el futuro y facilitará la colaboración con otros desarrolladores.