Cómo comprobar si una rama de Git está adelantada con respecto a la rama remota

Introducción

En este laboratorio, aprenderemos cómo verificar si tu rama local de Git está por delante de su rama remota correspondiente. Esta es una habilidad crucial para entender el estado de tu repositorio antes de enviar cambios. Exploraremos dos métodos principales: usar git status para ver el estado de "adelantado" y usar git log con la sintaxis @{u}..HEAD para ver los commits específicos que están por delante.

A través de ejercicios prácticos, simularemos realizar commits locales y luego usaremos estos comandos para observar cómo Git indica que nuestra rama local se ha desviado de la remota. Finalmente, probaremos estos métodos con ramas sincronizadas para ver la salida esperada cuando no hay commits por delante.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/DataManagementGroup(["Data Management"]) 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/DataManagementGroup -.-> git/reset("Undo Changes") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560041{{"Cómo comprobar si una rama de Git está adelantada con respecto a la rama remota"}} git/status -.-> lab-560041{{"Cómo comprobar si una rama de Git está adelantada con respecto a la rama remota"}} git/commit -.-> lab-560041{{"Cómo comprobar si una rama de Git está adelantada con respecto a la rama remota"}} git/reset -.-> lab-560041{{"Cómo comprobar si una rama de Git está adelantada con respecto a la rama remota"}} git/log -.-> lab-560041{{"Cómo comprobar si una rama de Git está adelantada con respecto a la rama remota"}} end

Verificar el estado de Git para el estado de "adelantado"

En este paso, aprenderemos cómo verificar el estado de nuestro repositorio de Git, centrándonos específicamente en cómo Git nos indica si nuestra rama local está "adelantada" con respecto a una rama remota. Este es un escenario común cuando has realizado commits localmente pero aún no los has enviado a un repositorio remoto.

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, creemos un nuevo archivo y agreguemos algo de contenido a él. Simularemos realizar un cambio que eventualmente confirmaremos.

echo "Another message for the future" >> message.txt

Este comando agrega el texto "Another message for the future" al archivo message.txt existente.

A continuación, preparemos este cambio utilizando git add:

git add message.txt

Ahora, creemos un nuevo commit con un mensaje que describa el cambio:

git commit -m "Add another message"

Deberías ver una salida similar a esta, lo que indica que se ha creado un nuevo commit:

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

¡Genial! Ahora hemos realizado un nuevo commit en nuestra rama local master. Sin embargo, este commit solo existe localmente. Si tuviéramos un repositorio remoto (como en GitHub o GitLab), este commit aún no estaría allí.

Verifiquemos el estado de nuestro repositorio nuevamente utilizando git status:

git status

Esta vez, la salida será un poco diferente. Deberías ver algo como esto:

On branch master
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean

Observa la línea Your branch is ahead of 'origin/master' by 1 commit.. Esto es lo que Git nos dice que nuestra rama local master tiene un commit que no está presente en la rama origin/master (que representa la rama master en un hipotético repositorio remoto llamado origin).

Este estado de "adelantado" es un indicador clave de que tienes cambios locales que deben ser enviados al repositorio remoto para compartirlos con otros o para respaldarlos de forma remota. Comprender este estado es crucial para colaborar con otros y mantener tus repositorios locales y remotos sincronizados.

Usar `git log @{u}..HEAD` para ver los commits adelantados

En el paso anterior, vimos que git status nos indicó que nuestra rama local estaba "adelantada" con respecto a la rama de seguimiento remota. Pero, ¿cómo podemos ver qué commits están por delante? Git ofrece una forma poderosa de comparar ramas utilizando git log.

La sintaxis @{u}..HEAD es una forma abreviada en Git. @{u} se refiere a la rama upstream (la rama de seguimiento remota a la que está configurada para seguir tu rama actual, como origin/master), y HEAD se refiere al extremo de tu rama local actual. Entonces, @{u}..HEAD significa "muéstrame los commits que están en mi rama actual (HEAD) pero no en la rama upstream (@{u})".

Intentemos este comando en nuestra terminal. Asegúrate de que todavía estás en el directorio ~/project/my-time-machine:

cd ~/project/my-time-machine
git log @{u}..HEAD

Deberías ver la entrada del log para el commit que hicimos en el paso anterior:

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

    Add another message

(Nota: El hash del commit y la fecha serán diferentes en tu salida, pero el mensaje del commit debe ser el mismo.)

Este comando es increíblemente útil para ver exactamente qué cambios estás a punto de enviar a un repositorio remoto. Te ayuda a revisar tu trabajo y a asegurarte de que solo estás enviando los commits deseados.

La sintaxis @{u}..HEAD es un ejemplo específico de la notación de rangos de Git para git log. Puedes usar una sintaxis similar para comparar cualquier par de commits o ramas. Por ejemplo, branch1..branch2 muestra los commits en branch2 que no están en branch1.

Comprender cómo usar git log con notación de rangos te da un control detallado para ver la historia de tu proyecto y comparar diferentes estados de tu repositorio.

Presiona q para salir de la vista del log y volver a la línea de comandos.

Probar con ramas sincronizadas

En los pasos anteriores, vimos lo que sucede cuando nuestra rama local está adelantada con respecto a la rama de seguimiento remota. Ahora, veamos qué muestran git status y git log @{u}..HEAD cuando nuestra rama local está sincronizada con la rama de seguimiento remota.

Dado que no tenemos un repositorio remoto real en este entorno de laboratorio, podemos simular la sincronización eliminando el commit que acabamos de hacer. En un escenario real, estar sincronizado significaría que has enviado tus commits locales al repositorio remoto.

Podemos usar git reset para mover el puntero de nuestra rama local al commit anterior. Ten cuidado con git reset en proyectos reales, ya que puede descartar cambios. Para este laboratorio, es seguro porque solo estamos simulando un estado.

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

cd ~/project/my-time-machine

Ahora, restablezcamos nuestra rama al commit anterior al último. Podemos usar HEAD~1 para referirnos al commit anterior al HEAD actual.

git reset --hard HEAD~1

Deberías ver una salida similar a esta, lo que indica que el HEAD se ha movido hacia atrás y el directorio de trabajo se ha actualizado:

HEAD is now at a1b2c3d Send a message to the future

(Nota: El hash del commit coincidirá con el hash de tu primer commit.)

Ahora que hemos restablecido nuestra rama local al estado del primer commit, veamos el estado nuevamente:

git status

Esta vez, la salida debe indicar que tu rama está actualizada con la rama de seguimiento remota:

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

El mensaje Your branch is up to date with 'origin/master'. nos dice que nuestra rama local master está sincronizada con la rama de seguimiento remota.

Finalmente, usemos git log @{u}..HEAD nuevamente para ver si hay algún commit adelantado:

git log @{u}..HEAD

Este comando no debe producir ninguna salida, porque no hay commits en nuestra rama local (HEAD) que no estén también en la rama upstream (@{u}).

Esto confirma que nuestra rama local ahora está sincronizada con la rama de seguimiento remota. Comprender la salida de git status y usar git log @{u}..HEAD son habilidades esenciales para gestionar tu flujo de trabajo de Git y colaborar de manera efectiva.

Resumen

En este laboratorio, aprendimos cómo verificar si una rama local de Git está adelantada con respecto a su rama remota correspondiente. Comenzamos realizando un commit local y luego usamos git status para observar el mensaje de estado "adelantada", que indica que la rama local contiene commits que aún no están presentes en la rama remota.

También exploramos el uso de git log @{u}..HEAD para listar específicamente los commits que están por delante de la rama de seguimiento remota, lo que proporciona una vista más detallada de las diferencias. Finalmente, probamos el comportamiento con ramas sincronizadas para confirmar que git status informa que las ramas están actualizadas cuando no hay commits locales por delante de la rama remota.