Cómo comprobar si una rama de Git se ha desviado de la remota

Introducción

En este laboratorio, aprenderás cómo comprobar si tu rama local de Git se ha desviado de su contraparte remota. Esta es una habilidad fundamental para el desarrollo colaborativo y para mantenerse actualizado con los cambios del proyecto.

Comenzaremos recuperando actualizaciones de un repositorio remoto simulado y utilizando git status para identificar si tu rama local está atrasada. Posteriormente, explorarás cómo utilizar git log para comparar confirmaciones (commits) entre tu rama local y la remota y, finalmente, verificar la desviación utilizando git diff @{u} HEAD.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git(("Git")) -.-> git/CollaborationandSharingGroup(["Collaboration and Sharing"]) git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/diff("Compare Changes") git/BranchManagementGroup -.-> git/log("Show Commits") git/CollaborationandSharingGroup -.-> git/fetch("Download Updates") subgraph Lab Skills git/status -.-> lab-560038{{"Cómo comprobar si una rama de Git se ha desviado de la remota"}} git/diff -.-> lab-560038{{"Cómo comprobar si una rama de Git se ha desviado de la remota"}} git/log -.-> lab-560038{{"Cómo comprobar si una rama de Git se ha desviado de la remota"}} git/fetch -.-> lab-560038{{"Cómo comprobar si una rama de Git se ha desviado de la remota"}} end

Recuperar y verificar el estado de Git para detectar desviaciones

En este paso, aprenderemos cómo comprobar si hay cambios en el repositorio remoto que no tengamos localmente. Esto es crucial cuando se colabora con otros o cuando se trabaja en un proyecto que se actualiza en otro lugar.

Primero, simulemos tener un repositorio remoto con algunos cambios. En un escenario real, este sería un repositorio alojado en una plataforma como GitHub o GitLab. Para este laboratorio, usaremos un directorio local como nuestro "remoto".

Vuelve al directorio de tu proyecto si no estás ya allí:

cd ~/project/my-time-machine

Ahora, recuperemos los últimos cambios del repositorio remoto simulado. Usaremos el comando git fetch. Este comando descarga confirmaciones (commits), archivos y referencias (refs) de un repositorio remoto a tu repositorio local. No los fusiona en tu rama actual.

git fetch origin

Puede que no veas mucha salida si no hay nuevos cambios. Sin embargo, git fetch actualiza la información sobre las ramas remotas en tu repositorio local.

A continuación, usaremos git status para ver si nuestra rama local está atrasada con respecto a la rama remota. El comando git status es tu ventana al estado actual de tu repositorio. Te informa sobre los archivos preparados (staged), no preparados (unstaged) y no rastreados (untracked), y también proporciona información sobre la relación entre tu rama actual y su rama upstream.

Ejecuta el comando git status:

git status

Si hubiera cambios en el remoto que acabas de recuperar, la salida de git status indicaría que tu rama local está atrasada con respecto a la rama remota. Podría verse algo así:

On branch master
Your branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.
  (use "git pull" to update your local branch)

nothing to commit, working tree clean

Este mensaje te dice que tu rama local master está un commit detrás de la rama origin/master (la versión remota de la rama master). También sugiere usar git pull para actualizar tu rama local, lo cual cubriremos en un laboratorio posterior.

Comprender la salida de git status después de recuperar los cambios es importante porque te permite saber si hay nuevos cambios disponibles en el repositorio remoto antes de decidir integrarlos en tu trabajo local. Esto ayuda a prevenir posibles conflictos y te mantiene informado sobre el progreso del proyecto.

Usar `git log` para comparar confirmaciones (commits)

En el paso anterior, usamos git status para ver si nuestra rama local estaba atrasada con respecto a la remota. Ahora, usemos git log para ver las confirmaciones reales que están en la rama remota pero no en nuestra rama local.

El comando git log es increíblemente versátil. Te permite ver el historial de confirmaciones de muchas maneras diferentes. Para comparar nuestra rama local (HEAD) con la rama de seguimiento remota (origin/master), podemos usar la siguiente sintaxis:

git log HEAD..origin/master

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

cd ~/project/my-time-machine

Ahora, ejecuta el comando git log para comparar las ramas:

git log HEAD..origin/master

Si hay confirmaciones en origin/master que no están en tu HEAD local (que actualmente apunta a tu rama local master), este comando listará esas confirmaciones. La salida mostrará los detalles de la confirmación, incluyendo el hash de la confirmación, el autor, la fecha y el mensaje de confirmación, para cada confirmación que existe en origin/master pero no en tu rama actual.

Por ejemplo, si el remoto tuviera una nueva confirmación, la salida podría verse así:

commit abcdef1234567890abcdef1234567890abcdef (origin/master)
Author: Another User <[email protected]>
Date:   Tue Aug 8 10:00:00 2023 +0000

    Add a new feature

Esta salida muestra claramente la confirmación que está presente en el remoto pero no localmente. La sintaxis HEAD..origin/master le dice a Git que muestre las confirmaciones que son alcanzables desde origin/master pero no desde HEAD.

Usar git log de esta manera es una herramienta poderosa para entender las diferencias entre ramas y ver exactamente qué cambios obtendrías si actualizaras tu rama local. Proporciona más detalles que git status sobre las confirmaciones específicas que están causando la desviación.

Recuerda presionar q para salir de la vista del registro si se abre en un paginador.

Verificar con `git diff @{u} HEAD`

En los pasos anteriores, usamos git status para ver si nuestra rama local estaba atrasada con respecto a la remota y git log para ver las confirmaciones (commits) que eran diferentes. Ahora, usemos git diff para ver los cambios reales en el código introducidos por esas confirmaciones en la rama remota en comparación con nuestra rama local.

El comando git diff muestra las diferencias entre dos puntos en el historial de tu repositorio Git. Lo podemos usar para comparar nuestra rama local actual (HEAD) con su rama upstream. La rama upstream es la rama en el repositorio remoto que tu rama local está siguiendo. En nuestro caso, la rama upstream para master es origin/master. Git proporciona un atajo conveniente para la rama upstream: @{u} o @{upstream}.

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

cd ~/project/my-time-machine

Ahora, ejecuta el comando git diff para ver las diferencias entre tu rama local y su rama upstream:

git diff @{u} HEAD

Este comando te mostrará las diferencias línea por línea entre los archivos en tu confirmación actual (HEAD) y los archivos en la última confirmación de la rama upstream (@{u}).

Si hay cambios en el remoto que aún no has descargado, la salida mostrará esas diferencias. Por ejemplo, si se agregó una línea a message.txt en el remoto, la salida podría verse así:

diff --git a/message.txt b/message.txt
index a1b2c3d..e4f5g6h 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+This is a new line from the remote.

El signo + indica las líneas que están presentes en la rama upstream (@{u}) pero no en tu rama local (HEAD).

Usar git diff @{u} HEAD es una forma poderosa de previsualizar los cambios que existen en el remoto antes de fusionarlos en tu rama local. Te permite entender las modificaciones exactas que se han realizado, lo cual es muy útil para revisiones de código o simplemente para mantenerse informado sobre la evolución del proyecto.

Presiona q para salir de la vista de diferencias si se abre en un paginador.

Resumen

En este laboratorio, aprendimos cómo verificar si una rama local de Git se ha desviado de su contraparte remota. Comenzamos simulando un repositorio remoto y utilizando git fetch para recuperar los últimos cambios sin fusionarlos. Posteriormente, utilizamos git status para identificar rápidamente si nuestra rama local estaba atrasada con respecto a la remota, lo cual se indica con mensajes como "Your branch is behind 'origin/master' by X commit" (Tu rama está X confirmaciones detrás de 'origin/master').

Después de la comprobación inicial con git status, exploramos métodos más detallados para comparar ramas. Aprendimos cómo usar git log con varias opciones para visualizar el historial de confirmaciones y identificar las diferencias entre las ramas local y remota. Finalmente, descubrimos la utilidad de git diff @{u} HEAD para una comparación precisa de los cambios entre la rama upstream y el HEAD actual, lo que nos proporciona una visión clara de la desviación.