Cómo comprobar si un commit de Git fue modificado (amended)

Introducción

En este laboratorio, aprenderás cómo determinar si un commit de Git ha sido modificado (amended). Exploraremos el comando git reflog para ver el historial de actualizaciones de referencias, que puede revelar operaciones de modificación (amend).

También aprenderás cómo usar git log para comparar commits y entender las diferencias entre commits modificados (amended) y no modificados, adquiriendo habilidades prácticas para examinar el historial de tu repositorio.

Skills Graph

Verificar el git reflog para entradas de modificación (amend)

En este paso, exploraremos el comando git reflog y cómo nos ayuda a ver el historial de nuestro repositorio, incluyendo acciones como modificar (amend) commits.

Primero, asegúrate de estar en el directorio de tu proyecto. Abre tu terminal y navega hasta el directorio my-time-machine:

cd ~/project/my-time-machine

Ahora, usemos el comando git reflog para ver el historial de nuestro repositorio. El reflog (registro de referencias) registra las actualizaciones de las puntas de las ramas y otras referencias en el repositorio. Esto es diferente de git log, que muestra el historial de commits.

Escribe el siguiente comando:

git reflog

Deberías ver una salida similar a esta:

a1b2c3d (HEAD -> master) HEAD@{0}: commit: Send a message to the future
a1b2c3d (HEAD -> master) HEAD@{1}: initial commit (amend): Send a message to the future
e4f5g6h HEAD@{2}: commit (initial): Send a message to the future

Desglosemos esta salida:

• Cada línea representa una acción que actualizó una referencia (como HEAD).
• HEAD@{0} es la acción más reciente, HEAD@{1} es la acción anterior, y así sucesivamente.
• La primera parte de cada línea (a1b2c3d, e4f5g6h) es el hash del commit. Observa cómo el hash del commit cambia después de una operación de "modificación" (amend).
• El texto después del hash del commit describe la acción, como commit, initial commit (amend) o commit (initial).

El git reflog es una herramienta poderosa para recuperar commits perdidos o entender la secuencia de operaciones que condujo al estado actual de tu repositorio. Te muestra dónde ha estado tu HEAD, incluso si esos commits ya no forman parte del historial de una rama (por ejemplo, después de una modificación (amend) o rebase).

En la salida de ejemplo, puedes ver una entrada como initial commit (amend). Esto indica que el commit inicial fue modificado (amend). Modificar un commit reemplaza el último commit con un nuevo commit que incluye los cambios que has preparado (staged). Mientras que git log solo mostrará el commit final modificado, git reflog muestra tanto el commit inicial original como el modificado.

Comprender git reflog es crucial para navegar por el historial de tu proyecto, especialmente cuando usas comandos que reescriben el historial, como git commit --amend.

Usar git log para comparar commits

En este paso, usaremos el comando git log para ver el historial de commits y entender cómo difiere de git reflog, especialmente después de usar git commit --amend.

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

Ahora, veamos el historial de commits usando git log:

git log --oneline

La opción --oneline proporciona una vista concisa del historial de commits, mostrando cada commit en una sola línea.

Deberías ver una salida similar a esta:

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

Compara esta salida con la salida de git reflog en el paso anterior. Observa que git log solo muestra un commit, que es el commit final modificado (amended). No muestra el commit inicial original que fue reemplazado por la operación de modificación (amend).

Esta es una diferencia clave entre git log y git reflog. git log muestra el historial de commits alcanzables desde la punta de la rama actual, mientras que git reflog muestra el historial de donde HEAD y otras referencias han apuntado.

Puedes pensar en git log como la historia oficial publicada de tu proyecto, mientras que git reflog es tu diario personal de todo lo que has hecho en el repositorio.

También puedes usar git log para comparar diferentes commits. Aunque actualmente solo tenemos un commit en nuestro historial, en un proyecto real con múltiples commits, podrías usar comandos como git log commit1..commit2 para ver los commits entre dos puntos específicos del historial, o git diff commit1 commit2 para ver los cambios exactos introducidos entre dos commits.

Por ahora, es importante entender que git log muestra el historial de commits y git reflog muestra el historial de actualizaciones de referencias.

Probar commits sin modificar (sin amend)

En este paso, crearemos un nuevo commit sin usar la bandera --amend y observaremos cómo aparece en tanto git log como en git reflog. Esto ayudará a consolidar tu comprensión de cómo estos comandos registran el historial de manera diferente.

Primero, agreguemos más contenido a nuestro archivo message.txt. Añadiremos una nueva línea:

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

El operador >> agrega el texto al archivo existente, en lugar de sobrescribirlo.

Ahora, comprobemos el estado para ver los cambios:

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")

A continuación, necesitamos preparar (stage) los cambios:

git add message.txt

Y ahora, creemos un nuevo commit sin modificar el anterior:

git commit -m "Add another message"

Deberías ver una salida que confirme el nuevo commit:

[master 1a2b3c4] Add another message
 1 file changed, 1 insertion(+)

Ahora, comprobemos git log de nuevo:

git log --oneline

Esta vez, deberías ver dos commits:

1a2b3c4 (HEAD -> master) Add another message
a1b2c3d Send a message to the future

Ambos commits son visibles en git log porque el segundo commit se agregó encima del primero, extendiendo el historial de la rama.

Finalmente, comprobemos git reflog:

git reflog

Deberías ver una salida similar a esta:

1a2b3c4 (HEAD -> master) HEAD@{0}: commit: Add another message
1a2b3c4 (HEAD -> master) HEAD@{1}: commit (amend): Send a message to the future
e4f5g6h HEAD@{2}: commit (initial): Send a message to the future

Observa que git reflog muestra todas las acciones: el commit inicial, el commit inicial modificado y el nuevo commit que acabamos de crear. Cada acción que movió HEAD se registra.

Este paso demuestra que cuando creas un nuevo commit sin --amend, tanto git log como git reflog mostrarán el nuevo commit, pero git reflog seguirá conservando el historial del commit modificado, que git log no muestra.

Resumen

En este laboratorio (lab), aprendimos cómo comprobar si un commit de Git fue modificado (amended). Exploramos el comando git reflog, que proporciona un historial de actualizaciones de referencias como HEAD, lo que nos permite ver acciones como la modificación de commits. Al examinar la salida del reflog, podemos identificar entradas que indican una operación de modificación (amend) y observar cómo cambia el hash del commit después de dicha acción.

También aprendimos que git reflog es una herramienta valiosa para entender la secuencia de operaciones en un repositorio, incluso para commits que ya no son directamente accesibles a través de git log. Esto ayuda a recuperar trabajo perdido o a diagnosticar problemas en el historial del repositorio.