Git ve cada archivo de tu copia de trabajo de una de las siguientes maneras:

  1. Con seguimiento: un archivo que se ha preparado o confirmado previamente.
  2. Sin seguimiento: un archivo que no se ha preparado o confirmado.
  3. Ignorado: un archivo que se le ha indicado explícitamente a Git que ignore.

Los archivos ignorados suelen ser artefactos de compilación y archivos generados por el equipo que pueden derivarse de tu fuente de repositorios o que no deberían confirmarse por algún otro motivo. Estos son algunos ejemplos habituales:

  • Cachés de dependencias, como el contenido de /node_modules o /packages.
  • Código compilado, como los archivos .o, .pyc y .class.
  • Directorios de salida de compilación, como /bin, /out o /target.
  • Archivos generados en tiempo de ejecución, como .log, .lock o .tmp.
  • Archivos ocultos del sistema, como .DS_Store o Thumbs.db.
  • Archivos personales de configuración de IDE, como .idea/workspace.xml.

A los archivos ignorados se les hace un seguimiento en un archivo especial llamado .gitignore que se incorpora en la raíz de tu repositorio. No hay ningún comando explícito de git ignore: en su lugar, el archivo .gitignore debe editarse y confirmarse manualmente cuando se tengan nuevos archivos que se quieran ignorar. Los archivos .gitignore contienen patrones que se comparan con los nombres de archivo de tu repositorio para determinar si deberían ignorarse o no.

Patrones de git ignore

Los archivos .gitignore usan patrones globales para realizar una comparación con los nombres de los archivos. Puedes crear tus patrones con varios símbolos:

Patrón Coincidencias de ejemplo Explicación*
**/logs logs/debug.log
logs/monday/foo.bar
build/logs/debug.log
Puedes anteponer un patrón con dos asteriscos para que coincida con los directorios del repositorio.
**/logs/debug.log logs/debug.log
build/logs/debug.log
pero no
logs/build/debug.log
También puedes utilizar dos asteriscos para que coincida con distintos archivos en función de su nombre y el nombre de su directorio principal.
*.log debug.log
foo.log
.log
logs/debug.log
Un asterisco es un carácter comodín que coincide con cero o más caracteres.
*.log
!important.log
debug.log
trace.log
pero no
important.log
logs/important.log
Si antepones un signo de exclamación a un patrón, este se anula. Si un archivo coincide con un patrón, pero también con un patrón de anulación definido más adelante en el archivo, no se ignorará.
*.log
!important/*.log
trace.*
debug.log
important/trace.log
pero no
important/debug.log
Los patrones definidos después de un patrón de anulación volverán a ignorar los archivos previamente anulados.
/debug.log debug.log
pero no
logs/debug.log
Si antepones una barra oblicua, el patrón coincidirá únicamente con archivos de la raíz del repositorio.
debug.log debug.log
logs/debug.log
De manera predeterminada, los patrones coinciden con archivos de cualquier directorio.
debug?.log debug0.log
debugg.log
pero no
debug10.log
Un signo de interrogación hace que la coincidencia sea exactamente de un carácter.
debug[0-9].log debug0.log
debug1.log
pero no
debug10.log
También se pueden emplear corchetes para que la coincidencia sea de un solo carácter de un intervalo especificado.
debug[01].log debug0.log
debug1.log
pero no
debug2.log
debug01.log
Los corchetes hacen que la coincidencia sea de un solo carácter del conjunto especificado.
debug[!01].log debug2.log
pero no
debug0.log
debug1.log
debug01.log
Se puede utilizar un signo de exclamación para que el patrón coincida con cualquier carácter, excepto uno del conjunto especificado.
debug[a-z].log debuga.log
debugb.log
pero no
debug1.log
Los intervalos pueden ser numéricos o alfabéticos.
logs logs
logs/debug.log
logs/latest/foo.bar
build/logs
build/logs/debug.log
Si no añades una barra oblicua, el patrón coincidirá tanto con los archivos como con el contenido de los directorios que lleven ese nombre. En las coincidencias de ejemplo de la izquierda, se ignoran los directorios y los archivos con el nombre logs.
logs/ logs/debug.log
logs/latest/foo.bar
build/logs/foo.bar
build/logs/latest/debug.log
Al añadir una barra oblicua, se indica que el patrón es un directorio. Se ignorará todo el contenido de cualquier directorio del repositorio que coincida con ese nombre, incluidos todos sus archivos y subdirectorios.
logs/
!logs/important.log
logs/debug.log
logs/important.log
¡Un momento! ¿No debería anularse logs/important.log en el ejemplo de la izquierda?

No. A causa de una peculiaridad relacionada con el funcionamiento de Git, no puedes anular un archivo que se ha ignorado debido a un patrón que coincide con un directorio.
logs/**/debug.log logs/debug.log
logs/monday/debug.log
logs/monday/pm/debug.log
El uso de dos asteriscos hace que la coincidencia sea de cero o más directorios.
logs/*day/debug.log logs/monday/debug.log
logs/tuesday/debug.log
pero no
logs/latest/debug.log
También pueden usarse caracteres comodín en los nombres de los directorios.
logs/debug.log logs/debug.log
pero no
debug.log
build/logs/debug.log
Los patrones que especifican un archivo de un directorio en particular están relacionados con la raíz del repositorio (puedes anteponer una barra oblicua si quieres, pero no sucederá nada en especial).

** En estas explicaciones, se asume que tu archivo .gitignore está en el directorio de nivel superior de tu repositorio, como es habitual. Si el repositorio tiene varios archivos .gitignore, tan solo tienes que reemplazar mentalmente "raíz del repositorio" por "directorio que contiene el archivo .gitignore" (y considera la posibilidad de unificarlos para facilitarle el trabajo a tu equipo).*

Además de estos caracteres, puedes utilizar # para incluir comentarios en tu archivo .gitignore:

# ignore all logs *.log 

Puedes usar \ para desencadenar una secuencia de escape de los caracteres de los patrones de los archivos .gitignore si tienes archivos o directorios que los contengan:

# ignore the file literally named foo[01].txt foo\[01\].txt 

Archivos .gitignore compartidos en tu repositorio

Las reglas de git ignore suelen definirse en un archivo .gitignore en la raíz de tu repositorio. Sin embargo, puedes optar por definir varios archivos .gitignore en distintos directorios del repositorio. Cada patrón de un archivo .gitignore concreto se comprueba en relación con el directorio que contiene ese archivo. No obstante, lo habitual, y el enfoque más simple, es definir un solo archivo .gitignore en la raíz. Cuando el archivo .gitignore se incorpora, se le realiza un control de versiones como con cualquier otro archivo del repositorio y se comparte con tus compañeros de equipo al enviarlo. Por lo general, solo debes incluir patrones en los archivos .gitignore que beneficiarán a otros usuarios del repositorio.

Reglas personales de git ignore

También puedes definir patrones personales de git ignore para un repositorio concreto en un archivo especial en .git/info/exclude. Además de no aplicárseles el control de versiones, tampoco se distribuyen con tu repositorio, por lo que es un lugar adecuado para incluir patrones que probablemente solo te beneficien a ti. Por ejemplo, si tienes una configuración de inicio de sesión personalizada o herramientas especiales de desarrollo que generan archivos en el directorio de trabajo de tu repositorio, podrías plantearte la posibilidad de añadirlos a .git/info/exclude para evitar que se confirmen por accidente en el repositorio.

Reglas globales de git ignore

Asimismo, puedes definir patrones globales de git ignore para todos los repositorios en tu sistema local. Para ello, basta con establecer la propiedad core.excludesFile de Git. Tendrás que crear este archivo por ti mismo. Si no sabes con seguridad dónde colocar el archivo .gitignore global, una buena opción es tu directorio principal (además, luego te resultará más sencillo encontrarlo). Una vez que hayas creado el archivo, deberás configurar su ubicación con git config:

$ touch ~/.gitignore $ git config --global core.excludesFile ~/.gitignore 

Debes tener cuidado con los patrones que eliges ignorar de manera global, ya que hay distintos tipos de archivos relevantes para diversos proyectos. Los archivos especiales del sistema operativo (como .DS_Store y thumbs.db) o los archivos temporales creados por algunas herramientas para desarrolladores son típicos candidatos para ignorarse globalmente.

Omisión de un archivo previamente confirmado

Si quieres ignorar un archivo que has confirmado en el pasado deberás eliminarlo de tu repositorio y, a continuación, añadirle una regla de .gitignore. El uso de la opción --cached con git rm implica que el archivo se eliminará del repositorio, pero permanecerá en tu directorio de trabajo como un archivo ignorado.

$ echo debug.log >> .gitignore $ git rm --cached debug.log rm 'debug.log' $ git commit -m "Start ignoring debug.log" 

Puedes omitir la opción --cached si quieres eliminar el archivo tanto del repositorio como de tu sistema de archivos local.

Confirmación de un archivo ignorado

Es posible forzar la confirmación de un archivo ignorado en el repositorio mediante la opción -f (o --force) con git add:

$ cat .gitignore *.log $ git add -f debug.log $ git commit -m "Force adding debug.log" 

Puedes plantearte hacer esto si tienes un patrón general (como *.log) definido, pero quieres confirmar un archivo específico. Sin embargo, es mejor definir una excepción a la regla general:

$ echo !debug.log >> .gitignore $ cat .gitignore *.log !debug.log $ git add debug.log $ git commit -m "Adding debug.log" 

Este enfoque es más obvio y menos confuso para tus compañeros de equipo.

Almacenamiento de un archivo ignorado

El comando git stash es una potente función de Git para guardar temporalmente y revertir cambios locales, lo que te permite volver a aplicarlos más tarde. Como cabría esperar, de forma predeterminada, git stash ignora los archivos ignorados y solo almacena los cambios de los archivos de los que Git hace un seguimiento. Sin embargo, puedes invocar git stash con la opción --all para guardar también los cambios de los archivos ignorados y sin seguimiento.

Depuración de archivos .gitignore

Si tienes patrones de .gitignore complicados o patrones repartidos por varios archivos .gitignore, puede resultar difícil realizar un seguimiento del motivo por el que se ignora un archivo concreto. Puedes usar el comando git check-ignore con la opción -v (o --verbose) para determinar qué patrón está provocando que se ignore un archivo en particular:

$ git check-ignore -v debug.log .gitignore:3:*.log debug.log 

La salida muestra lo siguiente:

 :  :   

Puedes incluir varios nombres de archivos en git check-ignore si quieres; no es necesario que los nombres se correspondan con los archivos que haya en tu repositorio.

¿Listo para aprender a usar Git?

Prueba este tutorial interactivo.

Comienza ahora