Cómo comprobar si un archivo se modificó en un commit específico

Introducción

En este laboratorio, aprenderás cómo verificar si un archivo específico fue modificado en un commit (confirmación) particular de Git. Exploraremos diferentes comandos de Git para lograr esto.

Comenzarás utilizando el comando git show --name-only para ver los archivos modificados en un commit. Luego, aprenderás cómo usar git diff-tree para examinar los cambios en los archivos entre commits. Finalmente, probarás estos métodos con archivos no modificados para confirmar su comportamiento.

Usar el comando git show --name-only en un commit

En este paso, aprenderemos cómo usar el comando git show para obtener más detalles sobre un commit específico. Mientras que git log nos muestra un resumen de los commits, git show nos permite echar un vistazo dentro de una única cápsula del tiempo.

Usemos git show para ver los detalles de nuestro primer commit. También agregaremos la opción --name-only para ver solo los nombres de los archivos que se modificaron en ese commit.

Primero, asegúrate de estar en el directorio my-time-machine:

cd ~/project/my-time-machine

Ahora, ejecuta el comando git show con la opción --name-only. Puedes usar HEAD para referirte al último commit:

git show --name-only HEAD

Deberías ver una salida similar a esta:

commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> master)
Author: Jane Doe <jane.doe@example.com>
Date:   Mon Aug 7 10:00:00 2023 +0000

    Send a message to the future

message.txt

Desglosemos la salida:

• La primera parte es similar a lo que viste con git log, mostrando los detalles del commit (ID del commit, autor, fecha y mensaje).
• La última línea, message.txt, es la salida de la opción --name-only. Nos dice que el archivo message.txt se modificó en este commit.

El comando git show es increíblemente útil para inspeccionar commits individuales. Puedes usarlo para ver exactamente qué cambios se hicieron en un commit específico, qué archivos se vieron afectados y el mensaje del commit asociado a esos cambios. Esto te ayuda a entender en detalle la historia de tu proyecto.

En el siguiente paso, exploraremos otra forma de ver los cambios en los archivos entre commits usando git diff-tree.

Ejecutar git diff-tree para ver cambios en archivos

En este paso, exploraremos otro comando para ver qué archivos se modificaron en un commit: git diff-tree. Este comando se utiliza a menudo en scripting (programación de scripts) y automatización, pero también es útil para entender cómo Git rastrea los cambios.

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

Necesitamos el ID del commit de nuestro primer commit. Puedes obtenerlo ejecutando git log --oneline:

git log --oneline

Deberías ver una salida como esta (tu ID de commit será diferente):

a1b2c3d (HEAD -> master) Send a message to the future

Copia los primeros 7 caracteres del ID del commit (por ejemplo, a1b2c3d).

Ahora, ejecuta el comando git diff-tree. Usaremos la opción -r para mostrar los cambios de forma recursiva y la opción --name-only para mostrar solo los nombres de los archivos. Reemplaza YOUR_COMMIT_ID con el ID de commit que copiaste:

git diff-tree -r --name-only YOUR_COMMIT_ID

Por ejemplo, si tu ID de commit fuera a1b2c3d, ejecutarías:

git diff-tree -r --name-only a1b2c3d

Deberías ver una salida como esta:

message.txt

Este comando también nos muestra que message.txt fue el archivo modificado en ese commit.

Si bien git show --name-only suele ser más conveniente para uso interactivo, git diff-tree es un comando poderoso para comparar árboles (instantáneas de tu proyecto) y se utiliza con frecuencia en flujos de trabajo y scripts de Git más avanzados. Entender que Git rastrea los cambios entre estas instantáneas es clave para dominar el control de versiones.

Probar archivos no modificados

En este último paso, confirmaremos que Git identifica correctamente los archivos que no se han modificado desde el último commit. Esto refuerza el concepto de que Git solo rastrea los cambios.

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

Ejecuta nuevamente el comando git status:

git status

Deberías ver una salida como esta:

On branch master
nothing to commit, working tree clean

Este mensaje nos dice que no hay cambios en nuestro directorio de trabajo que necesiten ser confirmados (commiteados). Git detecta que el archivo message.txt es exactamente el mismo que en el último commit.

Ahora, creemos un nuevo archivo no rastreado para ver cómo reacciona Git:

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

Ejecuta git status nuevamente:

git status

Ahora deberías ver:

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

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

Git identifica correctamente temp.txt como un archivo no rastreado porque aún no le hemos dicho a Git que lo rastree usando git add. Esto demuestra que Git es consciente de los archivos en tu directorio, pero solo rastrea activamente aquellos que has agregado al repositorio.

Finalmente, limpiemos el archivo temporal:

rm temp.txt

Ejecuta git status una última vez:

git status

Deberías volver al estado de "nothing to commit, working tree clean" (nada que confirmar, árbol de trabajo limpio).

Este paso destaca cómo Git te ayuda a gestionar tu proyecto al mostrar claramente qué archivos se han modificado, cuáles están preparados (staged) para el próximo commit y cuáles no están rastreados. Esta información clara de estado es crucial para un control de versiones efectivo.

Resumen

En este laboratorio (lab), aprendimos cómo verificar si un archivo se modificó en un commit específico utilizando Git. Comenzamos utilizando el comando git show --name-only para ver los detalles de un commit y listar solo los nombres de los archivos que se modificaron. Esto proporcionó una forma rápida de ver qué archivos se vieron afectados por un commit en particular.

Luego exploramos el comando git diff-tree como otro método para identificar los cambios en los archivos dentro de un commit. Si bien se utiliza a menudo en scripting (programación de scripts), entender git diff-tree ayuda a comprender cómo Git rastrea las modificaciones. Estos comandos son herramientas valiosas para inspeccionar la historia de un proyecto y entender los cambios introducidos en commits individuales.