Cómo comprobar si un commit de Git es el más reciente

Introducción

En este laboratorio, aprenderás cómo verificar si un commit específico de Git es el último commit en tu repositorio. Exploraremos cómo usar el comando git log -1 para ver el commit más reciente al que apunta HEAD, y luego usaremos git rev-parse HEAD para obtener el identificador único de ese commit. Finalmente, probarás estos comandos con commits más antiguos para consolidar tu comprensión de cómo HEAD representa la posición actual en la historia de tu proyecto.

Skills Graph

Ejecutar git log -1 para verificar HEAD

En este paso, aprenderemos cómo verificar rápidamente el commit más reciente en nuestro repositorio de Git utilizando el comando git log -1. Esta es una forma práctica de ver el estado actual de la historia de tu proyecto sin ver todo el registro.

Primero, asegúrate de estar en el directorio my-time-machine. Si no estás, utiliza el comando cd para navegar hasta allí:

cd ~/project/my-time-machine

Ahora, ejecutemos el comando para ver el último commit:

git log -1

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

El comando git log -1 muestra los detalles del último commit realizado en la rama actual. La opción -1 le dice a Git que solo muestre el commit más reciente.

Observa la parte (HEAD -> master). HEAD es un puntero que siempre apunta al último commit en la rama actual. En este caso, está apuntando al último commit en la rama master. Piensa en HEAD como tu posición actual en la línea de tiempo del proyecto. Cuando realizas un nuevo commit, HEAD se mueve automáticamente hacia adelante para apuntar a ese nuevo commit.

Comprender HEAD es crucial porque muchos comandos de Git operan en el commit al que HEAD está apuntando. En los siguientes pasos, exploraremos cómo HEAD se relaciona con los identificadores de commit específicos.

Comparar un commit con git rev-parse HEAD

En el paso anterior, vimos que git log -1 muestra el commit al que apunta HEAD. Ahora, usemos el comando git rev-parse HEAD para obtener solo el identificador único (el hash SHA-1) del commit al que HEAD está apuntando actualmente.

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

Ejecuta el siguiente comando:

git rev-parse HEAD

Deberías ver una larga cadena de letras y números, que es el hash SHA-1 completo de tu último commit:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9

Compara esta salida con el hash del commit que viste en la salida de git log -1 del paso anterior. ¡Deben ser iguales!

El comando git rev-parse es un comando de nivel bajo de Git que se utiliza a menudo para traducir varios tipos de referencias de Git (como nombres de ramas, etiquetas o HEAD) en sus correspondientes hashes SHA-1. Es una herramienta poderosa para la escritura de scripts y la automatización en Git.

Al usar git rev-parse HEAD, esencialmente le estás preguntando a Git: "¿Cuál es el ID exacto del commit que representa mi posición actual (HEAD)?". Esto te da el identificador sin procesar de la instantánea con la que estás trabajando actualmente.

Comprender cómo obtener el hash del commit sin procesar es importante porque estos hashes son la forma fundamental en que Git rastrea versiones específicas de tu proyecto. Puedes usar estos hashes para hacer referencia a cualquier punto en la historia de tu proyecto.

Probar con commits antiguos

En los pasos anteriores, aprendimos sobre HEAD y cómo obtener su hash de commit. Ahora, veamos cómo Git se refiere a commits antiguos.

Actualmente, solo tenemos un commit en nuestro repositorio. Para demostrar cómo referirse a commits antiguos, necesitamos hacer otro commit.

Primero, agreguemos otra línea a nuestro archivo message.txt. Utiliza el comando echo con >> para agregar texto al archivo:

echo "This is a second message." >> message.txt

Ahora, veamos el estado:

git status

Deberías ver 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)

Ahora, prepara los cambios y crea un nuevo commit:

git add message.txt
git commit -m "Add a second message"

Deberías ver una salida que indique que se ha creado un nuevo commit:

[master a1b2c3d] Add a second message
 1 file changed, 1 insertion(+)

Ahora tenemos dos commits. Volvamos a ver el registro:

git log --oneline

La opción --oneline ofrece una vista concisa del registro. Deberías ver algo como esto (los hashes serán diferentes):

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

El commit de la parte superior es el más reciente, y es donde apunta HEAD. El commit debajo es el más antiguo.

Git proporciona formas de referirse a commits en relación con HEAD. El commit justo antes de HEAD se puede referir como HEAD~1 o HEAD^. Intentemos obtener el hash del commit anterior utilizando git rev-parse:

git rev-parse HEAD~1

Deberías ver el hash del primer commit que hiciste:

e4f5g6h7i8j9k0l1m2n3o4p5q6r7s8t9u0v1w2x3

Este hash debe coincidir con el hash del commit "Send a message to the future" en la salida de git log --oneline.

Puedes usar HEAD~2, HEAD~3, y así sucesivamente, para referirte a commits más atrás en la historia. Esta referencia relativa es muy útil para navegar por la historia de tu proyecto y realizar operaciones en versiones específicas del pasado.

Resumen

En este laboratorio, aprendimos cómo verificar si un commit de Git es el más reciente al entender el papel de HEAD. Utilizamos el comando git log -1 para ver los detalles del commit más reciente, observando que HEAD apunta a este commit. Luego, usamos git rev-parse HEAD para obtener el hash SHA-1 único del commit al que HEAD está apuntando actualmente, que representa el commit más reciente en la rama actual.