.gitignore en Git: qué es, para qué sirve y cómo usarlo

El archivo .gitignore es una herramienta esencial para mantener cualquier repositorio organizado y libre de archivos innecesarios. En este artículo aprenderás qué es, para qué sirve, cómo crearlo paso a paso y cómo utilizarlo correctamente para evitar errores comunes y proteger información importante en tus proyectos con Git.

1. ¿Qué es el archivo .gitignore?

El archivo .gitignore es un archivo de texto especial que contiene una lista de reglas indicando a Git qué archivos o carpetas debe ignorar.

En otras palabras:

• Git no realizará seguimiento de esos archivos.
• No aparecerán en git status como archivos sin seguimiento.
• No podrán agregarse accidentalmente con git add ..

Es una de las primeras configuraciones que suele realizarse al comenzar un proyecto.

2. ¿Para qué sirve?

Su objetivo principal es evitar que el repositorio almacene archivos que no son necesarios para el proyecto.

Entre sus principales ventajas encontramos:

• Mantiene el repositorio más limpio.
• Evita subir archivos temporales.
• Protege información privada.
• Reduce el tamaño del repositorio.
• Facilita el trabajo en equipo.
• Evita conflictos innecesarios entre desarrolladores.

3. ¿Cuándo conviene utilizarlo?

Lo habitual es crearlo apenas se inicia un proyecto.

Por ejemplo:

• Después de ejecutar git init.
• Antes del primer commit.
• Antes de instalar dependencias.
• Antes de comenzar a trabajar con varios desarrolladores.

Aunque también puede agregarse más adelante sin ningún problema.

4. ¿Qué tipo de archivos suelen ignorarse?

Los proyectos suelen contener muchos archivos que no forman parte realmente del código fuente.

Algunos ejemplos son:

4.1. Archivos temporales

Son archivos creados automáticamente por programas.

Ejemplos:

• archivos temporales
• archivos de caché
• archivos de respaldo

4.2. Dependencias instaladas

En muchos proyectos se descargan miles de archivos automáticamente.

Por ejemplo:

• node_modules
• paquetes descargados
• librerías generadas automáticamente

Estos archivos pueden volver a generarse cuando otro desarrollador instala las dependencias.

4.3. Archivos de configuración personal

Cada desarrollador puede tener configuraciones diferentes.

Ejemplos:

• configuraciones del editor
• preferencias personales
• configuraciones locales

4.4. Información confidencial

Nunca deberían subirse datos sensibles como:

• contraseñas
• tokens
• API Keys
• certificados
• archivos .env

4.5. Archivos generados automáticamente

Algunos programas generan archivos durante la compilación.

Ejemplo:

• carpetas dist
• carpetas build
• archivos compilados

5. ¿Cómo crear un archivo .gitignore usando la terminal de VS Code?

Una forma muy sencilla consiste en utilizar la terminal integrada.

Paso 1. Abrir la terminal

En VS Code selecciona:

Terminal → New Terminal

Paso 2. Crear el archivo

Ejecuta:

touch .gitignoreLenguaje del código: CSS (css)

En Windows, si touch no está disponible, puedes utilizar:

echo.>.gitignoreLenguaje del código: CSS (css)

o bien:

type nul > .gitignoreLenguaje del código: CSS (css)

Paso 3. Abrir el archivo

Ahora aparecerá dentro del Explorador de VS Code.

Haz clic sobre él para editarlo.

Paso 4. Escribir las reglas

Por ejemplo:

node_modules/
.env
dist/

Guarda los cambios.

Paso 5. Verificar el resultado

Ahora ejecuta:

git status

Observarás que los archivos indicados ya no aparecen como archivos sin seguimiento (si aún no estaban siendo controlados por Git).

6. ¿Cómo crear .gitignore sin usar la terminal?

Muchos desarrolladores también suelen usar esta variante

Paso 1

En el Explorador de archivos pulsa:

Nuevo archivo

Paso 2

Escribe exactamente:

.gitignoreLenguaje del código: CSS (css)

Es importante escribir el punto inicial.

Paso 3

Abre el archivo.

Paso 4

Agrega las reglas necesarias.

Por ejemplo:

node_modules/
.env
dist/

Paso 5

Guarda el archivo.

Listo.

Git comenzará a respetar esas reglas automáticamente.

7. ¿Cómo funcionan las reglas de .gitignore?

Cada línea representa una regla distinta.

Por ejemplo:

node_modules/

Ignora toda esa carpeta.

---

*.logLenguaje del código: CSS (css)

Ignora todos los archivos con extensión .log.

---

*.tmpLenguaje del código: CSS (css)

Ignora cualquier archivo temporal.

---

.envLenguaje del código: CSS (css)

Ignora únicamente ese archivo.

---

dist/

Ignora toda la carpeta.

8. ¿Qué ocurre si un archivo ya estaba siendo controlado por Git?

Este es uno de los errores más comunes.

Supongamos que hiciste esto:

git add .env
git commit -m "Primer commit"Lenguaje del código: JavaScript (javascript)

Más tarde agregas:

.envLenguaje del código: CSS (css)

al archivo .gitignore.

Muchos principiantes creen que Git dejará de seguir ese archivo automáticamente.

Pero no ocurre así.

Git ya lo está controlando.

8.1. ¿Cómo dejar de seguir ese archivo?

Primero debes quitarlo del índice de Git.

Ejecuta:

git rm --cached .envLenguaje del código: CSS (css)

Luego realiza un nuevo commit.

Desde ese momento Git dejará de controlar ese archivo y comenzará a respetar la regla definida en .gitignore.

Importante: El archivo no se elimina de tu computadora. La opción --cached únicamente lo quita del repositorio (índice de Git), dejando intacta la copia local.

9. Casos reales donde normalmente se utiliza

9.1. Proyecto con Node.js

Se ignora:

node_modules/

Porque cualquier desarrollador puede instalar nuevamente las dependencias usando el archivo package.json.

9.2. Proyecto con variables privadas

Se ignora:

.envLenguaje del código: CSS (css)

Para evitar publicar:

• contraseñas
• claves privadas
• API Keys

9.3. Proyecto grande

Se ignora:

dist/
build/

Porque esos archivos se generan automáticamente durante la compilación.

9.4. Proyecto en Visual Studio Code

Puede ignorarse:

.vscode/

Cuando las configuraciones son personales y no deben compartirse con el equipo.

10. Ejemplo práctico usando .gitignore

Imagina que estás desarrollando un sitio web en Visual Studio Code.

La estructura del proyecto es la siguiente:

mi-proyecto
│
├── index.html
├── estilos.css
├── script.js
├── node_modules/
├── dist/
├── .env
├── errores.log
└── .gitignore

Tu objetivo es compartir únicamente el código fuente del proyecto.

No deseas subir:

• las dependencias (node_modules)
• la carpeta compilada (dist)
• las claves privadas (.env)
• los registros de errores (errores.log)

Para ello, creas el archivo .gitignore con el siguiente contenido:

node_modules/
dist/
.env
*.log

A partir de ese momento:

• index.html, estilos.css y script.js seguirán siendo controlados por Git.
• La carpeta node_modules será ignorada.
• La carpeta dist no aparecerá en git status.
• El archivo .env, donde guardas tus claves privadas, no podrá agregarse accidentalmente al repositorio.
• Cualquier archivo con extensión .log, como errores.log, también será ignorado.

De esta forma, el repositorio contiene únicamente los archivos necesarios para que cualquier integrante del equipo pueda descargar el proyecto y continuar trabajando, mientras que los archivos generados automáticamente, temporales o con información sensible permanecen fuera del control de versiones.

11. Buenas prácticas al utilizar .gitignore

• Crea el archivo al iniciar el proyecto.
• Mantén el archivo actualizado conforme evoluciona el proyecto.
• Nunca subas contraseñas, tokens o claves privadas.
• Ignora archivos generados automáticamente que puedan recrearse fácilmente.
• Revisa periódicamente el contenido del archivo para eliminar reglas innecesarias.
• Si trabajas en equipo, acuerda con los demás desarrolladores qué archivos deben compartirse y cuáles deben permanecer fuera del repositorio.

12. Resumen

El archivo .gitignore permite indicar a Git qué archivos y carpetas deben quedar fuera del control de versiones. Su uso ayuda a mantener el repositorio limpio, evita compartir información sensible y reduce la posibilidad de cometer errores al subir archivos innecesarios. Aprender a configurarlo correctamente es una práctica esencial para cualquier desarrollador que trabaje con Git, tanto en proyectos individuales como colaborativos.