Cómo comprobar si un archivo se ha agregado en un commit de Git

Introducción

En este laboratorio, aprenderás cómo verificar si se agregó un archivo en un commit específico de Git. Explorarás diferentes comandos de Git para inspeccionar los detalles de los commits e identificar los archivos recién agregados.

Comenzarás utilizando git show --name-status para ver un resumen conciso de los cambios en un commit, buscando específicamente el estado 'A' que indica un archivo agregado. Luego, aprenderás cómo usar git diff-tree con opciones relevantes para lograr un resultado similar, lo cual es especialmente útil para scripting (programación de scripts) y escenarios avanzados. Finalmente, diferenciarás entre archivos modificados y agregados dentro del historial de commits.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BasicOperationsGroup -.-> git/diff("Compare Changes") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560024{{"Cómo comprobar si un archivo se ha agregado en un commit de Git"}} git/status -.-> lab-560024{{"Cómo comprobar si un archivo se ha agregado en un commit de Git"}} git/commit -.-> lab-560024{{"Cómo comprobar si un archivo se ha agregado en un commit de Git"}} git/diff -.-> lab-560024{{"Cómo comprobar si un archivo se ha agregado en un commit de Git"}} git/log -.-> lab-560024{{"Cómo comprobar si un archivo se ha agregado en un commit de Git"}} end

Ejecutar git show --name-status

En este paso, exploraremos cómo ver los detalles de un commit específico, incluyendo qué archivos se cambiaron y cómo. Utilizaremos el comando git show con la opción --name-status.

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

cd ~/project/my-time-machine

Ahora, usemos git show para ver el commit que hicimos en el laboratorio anterior. Podemos usar el alias HEAD para referirnos al commit más reciente:

git show --name-status HEAD

Deberías ver una salida similar a esta:

commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> master)
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:00:00 2023 +0000

    Send a message to the future

A       message.txt

Desglosemos esta salida:

La primera parte muestra los detalles del commit, similar a lo que viste con git log.
La línea A message.txt es la parte importante aquí.
- A significa "Agregado". Esto nos dice que el archivo message.txt se agregó en este commit.
- message.txt es el nombre del archivo que se afectó.

La opción --name-status es muy útil porque te da un resumen conciso de los cambios introducidos por un commit, mostrando solo los nombres de los archivos y su estado (Agregado, Modificado, Eliminado, etc.). Esto es más rápido que ver la diferencia completa si solo quieres saber qué archivos estuvieron involucrados.

Comprender cómo inspeccionar los commits es crucial para navegar por el historial de tu proyecto y entender cómo ha evolucionado.

Usar git diff-tree para archivos agregados

En este paso, usaremos otro comando, git diff-tree, para ver los cambios introducidos por un commit. Mientras que git show es excelente para ver los detalles completos del commit y la diferencia, git diff-tree es útil para scripting (programación de scripts) y escenarios más avanzados.

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

Usaremos git diff-tree con las opciones -r (recursivo) y --name-status, seguidas del hash del commit. Puedes obtener el hash del commit de la salida de git log o git show. Para nuestro primer commit, también podemos usar HEAD.

git diff-tree -r --name-status HEAD

Deberías ver una salida similar a esta:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 A       message.txt

Veamos la salida:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 es el hash del commit.
A indica el estado del cambio del archivo (Agregado).
message.txt es el nombre del archivo.

Esta salida es muy similar a la parte --name-status de git show. Para un commit sencillo como nuestro primer commit (que solo agregó un archivo), la salida es casi idéntica. Sin embargo, git diff-tree es más flexible y se puede usar para comparar diferentes árboles (instantáneas) en tu repositorio, no solo commits.

Por ahora, la principal idea es que tanto git show --name-status como git diff-tree -r --name-status pueden mostrarte qué archivos se cambiaron y cómo en un commit dado. Esta es una habilidad fundamental para entender la historia de tu proyecto.

Probar archivos modificados vs archivos agregados

En los pasos anteriores, vimos cómo git show --name-status y git diff-tree --name-status muestran una A para un archivo agregado. Ahora, veamos cómo se comportan cuando un archivo se modifica.

Primero, asegúrate de estar en el directorio ~/project/my-time-machine.

Vamos a agregar otra línea a nuestro archivo message.txt:

echo "Hello again, Future Me" >> message.txt

El operador >> agrega el texto al archivo existente.

Ahora, veamos el estado de nuestro repositorio:

git status

Deberías ver una salida que indique que message.txt ha sido modificado:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

no changes added to commit (use "git add" and/or "git commit -a")

Git identifica correctamente que el archivo ha sido modificado.

Ahora, preparemos (stage) este cambio:

git add message.txt

Y veamos el estado nuevamente:

git status

La salida ahora debería mostrar que el cambio está preparado (staged):

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

Observa que, aunque agregamos contenido, Git registra esto como un archivo modificado porque el archivo ya existía en el commit anterior.

Finalmente, confirmemos (commit) este cambio:

git commit -m "Add another message to the future"

Deberías ver una salida que confirme el commit:

[master a1b2c3d] Add another message to the future
 1 file changed, 1 insertion(+)

Ahora tenemos un nuevo commit. Usemos git show --name-status en el commit más reciente (HEAD) para ver el estado:

git show --name-status HEAD

La salida será similar a esta:

commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> master)
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:05:00 2023 +0000

    Add another message to the future

M       message.txt

Observa la M antes de message.txt. Esto indica que el archivo fue Modificado en este commit.

De manera similar, si usas git diff-tree -r --name-status HEAD, también verás el estado M.

Esta distinción entre A (Agregado) y M (Modificado) es importante para entender la historia de tus archivos en Git. A significa que el archivo se creó en ese commit, mientras que M significa que el archivo existía antes y su contenido se cambió.

Resumen

En este laboratorio, aprendimos cómo verificar si un archivo se agregó en un commit de Git. Primero exploramos el comando git show --name-status, que proporciona un resumen conciso de los cambios en un commit, incluyendo el estado (como 'A' para Agregado) y el nombre de los archivos afectados. Esta es una forma rápida de ver qué archivos estuvieron involucrados en un commit sin ver la diferencia completa.

Luego introdujimos el comando git diff-tree con las opciones -r y --name-status como un método alternativo para inspeccionar los cambios de un commit, especialmente útil para scripting (programación de scripts) y escenarios avanzados. Aunque no se proporcionaron todos los detalles de este paso, la introducción indica que su propósito es explorar más cómo identificar archivos agregados dentro de un commit utilizando un comando de Git diferente.