.gitignore

git add git commit git diff git stash .gitignore

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

Con seguimiento: Un archivo que se ha preparado o confirmado previamente.
Sin seguimiento: Un archivo que no se ha preparado o confirmado.
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 es el caso del contenido de /node_modules o /packages.
Código compilado como, por ejemplo, los archivos .o, .pyc y .class.
Directorios de salida de compilación, como es el caso de /bin, /out o /target.
Archivos generados en tiempo de ejecución como, por ejemplo, .log, .lock o .tmp.
Archivos ocultos del sistema, como es el caso de .DS_Store o Thumbs.db.
Archivos personales de configuración de IDE como, por ejemplo, .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. En Git no hay ningún comando explícito para ignorar archivos: en su lugar, cuando tengas nuevos archivos que quieras ignorar, deberás editar y confirmar manualmente el archivo .gitignore. Los archivos .gitignore contienen patrones que establecen coincidencias con los nombres de archivo de tu repositorio para determinar si deberían ignorarse o no.

Ignorar archivos en Git

Patrones de git ignore

Los archivos .gitignore usan patrones globales para el establecimiento de coincidencias 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 dos asteriscos a un patrón para que coincida con directorios situados en cualquier lugar del repositorio.
`**/logs/debug.log`	`logs/debug.log` `build/logs/debug.log` but not `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` but not `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` but not `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` but not `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` but not `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` but not `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` but not `debug2.log` `debug01.log`	Los corchetes hacen que la coincidencia sea de un solo carácter del conjunto especificado.
`debug[!01].log`	`debug2.log` but not `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` but not `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`	Usar 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` but not `logs/latest/debug.log`	También pueden usarse caracteres comodín en los nombres de los directorios.
`logs/debug.log`	`logs/debug.log` but not `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 la barra oblicua invertida (\) para escapar los caracteres de un patrón de .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 ignoración de Git suelen definirse en un archivo .gitignore ubicado 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 ignoración de Git 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 ignoración de Git para todos los repositorios de 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 tienes claro dónde colocar el archivo .gitignore global, una buena opción es tu directorio principal (además, luego te resultará más sencillo encontrarlo). En cuanto 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 los distintos tipos de archivos son pertinentes para proyectos diferentes. Los archivos especiales del sistema operativo (como .DS_Store y thumbs.db) o los archivos temporales creados por algunas herramientas para desarrolladores son candidatos típicos 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. Al usar la opción --cached con git rm, el archivo se eliminará del repositorio, pero permanecerá en tu directorio de trabajo como 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

Se puede 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 definido un patrón general (como *.log), 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 cambios locales y revertirlos, 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 en stash 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 en el stash 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 averiguar el 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:

<file containing the pattern> : <line number of the pattern> : <pattern>    <file name>

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.