Git: ignorar archivos con .gitignore

Ignorar archivos manualmente es manejable en un proyecto pequeño. Esta tarea se sale de control tan pronto como su proyecto crece, lo que puede causar muchos errores manuales y problemas con su compilación. En este artículo, veremos cómo usar .gitignore para ignorar los archivos que queremos que se omitan del repositorio.

Git es una gran herramienta para rastrear todos los archivos en un proyecto, ya sea que tenga solo unos pocos para rastrear o miles. Pero el hecho de que exista un archivo en su proyecto no significa que automáticamente desee realizar un seguimiento de él y sus cambios durante la vida útil del proyecto.

En este artículo, veremos algunos antecedentes sobre por qué es importante decirle a Git que ignore ciertos archivos, cómo hacerlo y algunas mejores prácticas.

¿Por qué usar .gitignore?

Ignorar manualmente los archivos que no desea rastrear es manejable en un proyecto a pequeña escala, pero tan pronto como su proyecto comience a crecer e incluya decenas o cientos de archivos sin control de versión, puede convertirse en un gran problema. Estos archivos comenzarán a saturar la lista de "Archivos sin seguimiento", lo que puede hacer que pase por alto los archivos legítimos que deben estar en el repositorio.

Para ayudar con este problema, Git tiene un mecanismo "ignorar" en forma de un archivo llamado .gitignore. Con este archivo y una coincidencia de patrones muy simple, puede decirle a Git qué tipos de archivos desea que ignore y no rastree en su repositorio. Si un nombre de archivo en su proyecto coincide con uno de los patrones en el archivo .gitignore, Git no intentará rastrear el archivo y no aparecerá en la lista de "Archivos sin rastrear".

Qué archivos ignorar

Mucho de esto se reduce a preferencias personales, pero en general tiendo a seguir estas reglas generales sobre qué archivos no rastrear:

  • Archivos del sistema (es decir, Mac's .DS_Store)
  • Archivos de configuración de la aplicación (es decir, app.config, .env, etc.)
  • Crear artefactos (es decir, *.pyc)
  • Dependencias instaladas (es decir, node_modules)
  • Archivos de texto personales y no documentales (es decir, todo.txt)
  • Datos y registros de la aplicación (es decir, *.log, *.sqlite, etc.)

Hay bastantes otros tipos de archivos que a menudo se ignoran, pero mucho de esto se debe a preferencias personales, como los siguientes:

  • Archivos de configuración de desarrollo (es decir, .jshintrc)
  • Código fuente generado o minimizado (es decir, *.min.js)
  • .gitignore

Sí, incluso se debate el seguimiento del propio archivo .gitignore.

Los consejos que se dan aquí pueden cambiar según con quién hable, por lo que es posible que desee tomar algunos de estos con un grano de sal. Todos tienen sus opiniones sobre lo que se debe o no se debe rastrear, por lo que su mejor opción es revisar ambos lados del debate y luego tomar una decisión por sí mismo en función de lo que es mejor para su proyecto.

Usando .gitignore

Los conceptos básicos del uso de esta función de ignorar son bastante sencillos, que es lo que veremos en esta sección.

Por el bien de nuestro ejemplo, digamos que tenemos un nuevo proyecto con los siguientes archivos sin seguimiento:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
$ git status
On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

    .DS_Store
    .env-dev
    .env-prod
    index.js
    node_modules/
    package-lock.json
    package.json

Es un poco inútil rastrear los archivos .DS_Store y node_modules/ en nuestro repositorio, por lo que queremos ignorarlos. Para hacerlo, primero crearemos un archivo en el directorio raíz del proyecto llamado .gitignore:

1
$ touch .gitignore

La forma más sencilla de ignorar un archivo, y la más común, es simplemente agregar el nombre completo del archivo al archivo ignorado. Entonces, para ignorar los archivos anteriores, por ejemplo, querremos agregar lo siguiente:

1
2
.DS_Store
node_modules

Una vez guardado, Git ahora nos mostrará los siguientes archivos sin seguimiento:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
$ git status

...

Untracked files:
  (use "git add <file>..." to include in what will be committed)

    .env-dev
    .env-prod
    .gitignore
    index.js
    package-lock.json
    package.json

Tanto .DS_Store como node_modules ya no están en la lista de "Archivos sin seguimiento", pero todavía tenemos algunos de los que queremos deshacernos, .env-dev y .env-prod. Para evitar tener que agregar explícitamente cada uno a .gitignore (especialmente si tenemos que agregar más de estos archivos para entornos de prueba y ensayo), usaremos un comodín:

1
2
3
.DS_Store
node_modules
.env-*

Y ahora nuestra lista de "Archivos sin seguimiento" se ha reducido aún más:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
$ git status

...

Untracked files:
  (use "git add <file>..." to include in what will be committed)

    .gitignore
    index.js
    package-lock.json
    package.json

El carácter comodín (*) coincidirá con cualquier cosa excepto con una barra oblicua. Y el uso de dos caracteres comodín seguidos (**) seguidos de una barra inclinada coincidirá con su patrón en todos los directorios. Entonces, por ejemplo, public/**/*.min.js ignorará todos los archivos JavaScript minificados en el directorio public, independientemente de cuántos directorios tengan.

El mecanismo de ignorar de Git también admite una sintaxis similar a expresión regular simple, con alguna sintaxis adicional propia:

  • [a-zA-Z]: coincide con un rango de caracteres
  • ?: coincide con 0 o 1 ocurrencias del elemento anterior
  • !: niega la coincidencia o el carácter anterior

Git también le permite agregar comentarios a este archivo, que comienzan con #. Esto es muy útil para organizar el archivo o agregar explicaciones sobre por qué se agregaron ciertos patrones.

Jerarquía de archivos .gitignore

Git en realidad verifica más que solo el archivo local .gitignore para saber qué archivos debe ignorar. Como hemos visto hasta ahora, la ubicación más común es colocar un archivo .gitignore en el directorio raíz de su proyecto. Otra opción es tener un archivo .gitignore anidado en un directorio de tu proyecto. Si bien es menos común en la práctica, esto puede ser útil para aplicar un archivo de ignorar completo en un subdirectorio que tiene muchas reglas propias.

Otra característica útil es un archivo de ignorar global. Este suele ser un archivo .gitignore ubicado en su directorio de inicio:

1
$ touch ~/.gitignore

Si es necesario, puede cambiar la ubicación de este archivo global con el siguiente comando:

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

Cualquier patrón colocado en este archivo debe ser para los tipos de archivos que usted está seguro de que nunca querrá rastrear, como el archivo .DS_Store para los usuarios de Mac. Es fácil olvidarse de este archivo ignorado globalmente, lo que puede causar mucha confusión o problemas cuando se pierde la confirmación de un archivo porque se ignoró globalmente.

Confirmar archivos ignorados

Digamos que tiene una excepción que desea hacer para un archivo que generalmente se ignora, pero por alguna razón este proyecto en particular lo necesita. En casos como este tienes algunas opciones:

  1. Dígale a Git que no ignore este archivo anteponiendo el nombre del archivo con un ! en .gitignore, es decir, !.env. Esto anulará cualquier archivo ignorado global o archivos ignorados en los directorios principales.
  2. Use la opción --force (o el indicador -f) cuando prepare sus archivos, es decir, git add .env --force

Conclusión

En este artículo, vimos cómo Git proporciona un mecanismo para que le indiquemos qué archivos no deben rastrearse en nuestro repositorio, lo que evita que tengamos que evitar manualmente que se agreguen archivos. Esta es una característica poderosa que proporciona una sintaxis rica, así como una jerarquía para controlar mejor qué archivos se ignoran y cuáles no.

Licensed under CC BY-NC-SA 4.0