Cómo comprobar si un archivo es ignorado por Git

Introducción

En este laboratorio, aprenderás cómo usar el comando git check-ignore para determinar si un archivo está siendo ignorado por Git. Crearás un archivo .gitignore, agregarás patrones a él y luego usarás git check-ignore para verificar qué archivos están siendo ignorados y por qué.

También explorarás cómo diferentes patrones en el archivo .gitignore afectan qué archivos se excluyen del seguimiento, lo que te permitirá comprender en profundidad cómo Git maneja los archivos ignorados.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git(("Git")) -.-> git/SetupandConfigGroup(["Setup and Config"]) git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git/SetupandConfigGroup -.-> git/git("Show Version") git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/clean("Clean Workspace") git/BranchManagementGroup -.-> git/checkout("Switch Branches") subgraph Lab Skills git/git -.-> lab-560027{{"Cómo comprobar si un archivo es ignorado por Git"}} git/add -.-> lab-560027{{"Cómo comprobar si un archivo es ignorado por Git"}} git/status -.-> lab-560027{{"Cómo comprobar si un archivo es ignorado por Git"}} git/clean -.-> lab-560027{{"Cómo comprobar si un archivo es ignorado por Git"}} git/checkout -.-> lab-560027{{"Cómo comprobar si un archivo es ignorado por Git"}} end

Ejecutar git check-ignore en un archivo

En este paso, aprenderemos cómo usar el comando git check-ignore. Este comando es muy útil para entender por qué Git está ignorando ciertos archivos o directorios. Te ayuda a depurar tu archivo .gitignore.

Primero, asegúrate de estar en el directorio de tu proyecto. Abre tu terminal y escribe:

cd ~/project/my-time-machine

Ahora, creemos un archivo que esperamos que Git ignore. Crearemos un archivo llamado temp.log. A menudo, los archivos de registro (log files) se ignoran en los repositorios de Git.

echo "This is a temporary log file." > temp.log

A continuación, creemos un archivo .gitignore y agreguemos un patrón para ignorar archivos .log.

echo "*.log" > .gitignore

Ahora, podemos usar git check-ignore para ver si Git está ignorando temp.log.

git check-ignore temp.log

Si Git está ignorando el archivo, el comando mostrará el patrón del archivo .gitignore que coincide con el archivo. Deberías ver una salida similar a esta:

.gitignore:1:*.log	temp.log

Esta salida nos dice que el archivo temp.log está siendo ignorado debido al patrón *.log en la línea 1 del archivo .gitignore.

Si el archivo no estuviera siendo ignorado, el comando no produciría ninguna salida.

Comprender git check-ignore es crucial para gestionar eficazmente los archivos de tu proyecto. Te impide cometer accidentalmente archivos que no quieres en tu repositorio, como archivos temporales, artefactos de compilación o archivos de configuración sensibles.

Verificar patrones de .gitignore

En este paso, exploraremos cómo diferentes patrones en .gitignore afectan qué archivos se ignoran. El archivo .gitignore utiliza patrones específicos para indicar a Git qué archivos o directorios excluir del seguimiento.

Asegúrate de que todavía estés en el directorio ~/project/my-time-machine.

Vamos a agregar algunos archivos más y modificar nuestro archivo .gitignore para ver cómo funcionan diferentes patrones.

Primero, crea algunos archivos nuevos:

mkdir build
echo "This is a build artifact." > build/output.txt
echo "Another log file." > error.log
echo "A temporary file." > temp.dat
echo "A configuration file." > config.ini

Ahora, editemos el archivo .gitignore para incluir más patrones. Podemos usar el editor nano para esto.

nano .gitignore

Dentro del editor nano, deberías ver *.log. Agrega las siguientes líneas debajo de él:

build/
*.dat
config.ini

Tu archivo .gitignore ahora debería verse así:

*.log
build/
*.dat
config.ini

Presiona Ctrl + X, luego Y y Enter para guardar y salir de nano.

Ahora, usemos git check-ignore con la bandera -v para ver qué patrón está ignorando cada archivo. La bandera -v proporciona una salida detallada, mostrando el patrón coincidente y el archivo fuente (.gitignore en este caso).

git check-ignore -v temp.log error.log build/output.txt temp.dat config.ini

Deberías ver una salida similar a esta:

.gitignore:1:*.log	temp.log
.gitignore:1:*.log	error.log
.gitignore:2:build/	build/output.txt
.gitignore:3:*.dat	temp.dat
.gitignore:4:config.ini	config.ini

Esta salida confirma que:

temp.log y error.log son ignorados por el patrón *.log.
build/output.txt es ignorado porque se está ignorando todo el directorio build/.
temp.dat es ignorado por el patrón *.dat.
config.ini es ignorado por el patrón config.ini.

Comprender estos patrones es esencial para mantener tu repositorio limpio y centrado solo en los archivos que deseas seguir.

Probar archivos no ignorados

En este paso, usaremos git check-ignore para confirmar que los archivos que no son ignorados por .gitignore no producen salida. Esto ayuda a consolidar tu comprensión de cómo funciona el comando y cómo verificar que Git está siguiendo los archivos que pretendes que siga.

Asegúrate de estar en el directorio ~/project/my-time-machine.

Ya tenemos el archivo message.txt de un laboratorio anterior. Este archivo no está listado en nuestro archivo .gitignore, por lo que Git no debería ignorarlo.

Usemos git check-ignore en message.txt:

git check-ignore message.txt

Como se esperaba, este comando no debería producir salida. Esto indica que message.txt no está siendo ignorado por ningún patrón en tu archivo .gitignore o por ninguna otra regla de ignorado.

Ahora, creemos otro archivo que no pretendemos ignorar:

echo "This file should be tracked." > important_file.txt

Y comprobemos su estado de ignorado:

git check-ignore important_file.txt

Nuevamente, no deberías ver salida, lo que confirma que important_file.txt no está siendo ignorado.

Finalmente, usemos git status para ver cómo Git ve estos archivos.

git status

Deberías ver una salida similar a esta:

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	new file:   .gitignore

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

nothing added to commit but untracked files present (use "git add" to track)

Observa que important_file.txt y message.txt están listados bajo "Untracked files" (Archivos no rastreados). Esto significa que Git los ve, pero actualmente no está rastreando sus cambios. Los archivos ignorados (temp.log, error.log, build/output.txt, temp.dat, config.ini) no se listan aquí porque se le ha indicado explícitamente a Git que los ignore.

Este paso refuerza el concepto de que git check-ignore es una herramienta para verificar las reglas de ignorado, y los archivos que no coinciden con las reglas de ignorado aparecerán como "Untracked" (No rastreados) en git status hasta que los agregues explícitamente para ser rastreados con git add.

Resumen

En este laboratorio, aprendimos cómo usar el comando git check-ignore para determinar si un archivo específico está siendo ignorado por Git. Practicamos la creación de un archivo .gitignore, agregamos patrones a él y luego usamos git check-ignore para verificar que los archivos deseados realmente estaban siendo ignorados. La salida de git check-ignore nos ayudó a entender qué patrón en el archivo .gitignore estaba causando que el archivo fuera ignorado.

También exploramos cómo diferentes patrones en el archivo .gitignore afectan qué archivos se ignoran. Al crear varios archivos y modificar el archivo .gitignore con diferentes patrones, obtuvimos una mejor comprensión de cómo Git interpreta estos patrones para excluir archivos y directorios del seguimiento. Este conocimiento es esencial para gestionar de manera efectiva qué archivos se incluyen en un repositorio de Git.