Cómo comprobar si una rama de Git está sincronizada con otra rama

Introducción

En este laboratorio, aprenderás cómo comprobar si una rama (branch) de Git está sincronizada con otra rama. Esta es una habilidad fundamental para gestionar la historia de tu proyecto y garantizar que las ramas estén actualizadas.

Explorarás tres métodos diferentes para lograr esto: utilizar git log para comparar los historiales de confirmación (commits), emplear git diff para identificar las diferencias entre las ramas y, finalmente, verificar la relación entre las ramas utilizando git merge-base. Al final de este laboratorio, estarás equipado con técnicas prácticas para determinar con confianza el estado de sincronización de tus ramas de Git.

Skills Graph

Usar git log para Comparar Confirmaciones (Commits)

En este paso, aprenderemos cómo usar el comando git log para comparar diferentes confirmaciones en la historia de tu proyecto. Esto es como mirar diferentes instantáneas de tu máquina del tiempo y ver cómo las cosas han cambiado entre ellas.

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

cd ~/project/my-time-machine

Ahora, creemos un nuevo archivo y hagamos una confirmación. Esto nos dará otro punto en la historia para comparar con nuestra primera confirmación.

echo "This is the second message." > second_message.txt
git add second_message.txt
git commit -m "Add a second message file"

Después de la confirmación, deberías ver una salida similar a esta:

[master a1b2c3d] Add a second message file
 1 file changed, 1 insertion(+)
 create mode 100644 second_message.txt

Ahora tenemos dos confirmaciones en nuestra historia. Volvamos a ver el registro (log):

git log

Verás dos entradas de confirmación, con la más reciente en la parte superior. Cada confirmación tiene un identificador único (la larga cadena de caracteres).

Para comparar dos confirmaciones específicas, podemos usar git log con la sintaxis de rango commit1..commit2. Esto muestra las confirmaciones que son alcanzables desde commit2 pero no desde commit1.

Encontremos los identificadores de confirmación de nuestras dos confirmaciones. Puedes obtener los identificadores cortos de la salida de git log --oneline. Por ejemplo, si el identificador de tu primera confirmación era a1b2c3d y el de tu segunda era e4f5g6h, usarías esos identificadores.

git log --oneline

Salida de ejemplo:

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

Ahora, comparemos el estado del proyecto entre la primera confirmación (a1b2c3d) y la segunda confirmación (e4f5g6h). Reemplaza los identificadores de ejemplo con los identificadores reales de tus confirmaciones:

git log a1b2c3d..e4f5g6h

Este comando te mostrará las confirmaciones que se hicieron después de la confirmación con el identificador a1b2c3d hasta y incluyendo la confirmación con el identificador e4f5g6h. En este caso, debería mostrarte la segunda confirmación.

Comprender cómo comparar confirmaciones usando git log es crucial para navegar por la historia de tu proyecto. Te permite ver la secuencia de cambios y entender la evolución de tu base de código.

Ejecutar git diff branch1 branch2

En el paso anterior, usamos git log para ver qué confirmaciones (commits) estaban presentes en diferentes partes de nuestra historia. Ahora, usemos el comando git diff para ver los cambios reales entre dos puntos diferentes en el tiempo o entre diferentes ramas (branches). Esto es como comparar dos versiones de tu máquina del tiempo y ver exactamente qué partes se agregaron, eliminaron o modificaron.

Primero, asegúrate de estar en el directorio de tu proyecto:

cd ~/project/my-time-machine

Actualmente, solo tenemos una rama, master. Para demostrar cómo comparar ramas, creemos una nueva rama llamada feature-branch. Piensa en una rama como una línea temporal alternativa donde puedes trabajar en nuevas características o experimentos sin afectar la línea temporal principal (master).

git branch feature-branch

Ahora, cambiemos a nuestra nueva rama:

git checkout feature-branch

Deberías ver una salida que indique que has cambiado de rama:

Switched to branch 'feature-branch'

En esta nueva rama, hagamos un cambio en nuestro archivo message.txt:

echo "Adding a line on the feature branch." >> message.txt

Este comando agrega una nueva línea al archivo message.txt.

Ahora, confirmemos este cambio en la rama feature-branch:

git add message.txt
git commit -m "Add a line to message.txt on feature branch"

Después de la confirmación, deberías ver una salida similar a esta:

[feature-branch a1b2c3d] Add a line to message.txt on feature branch
 1 file changed, 1 insertion(+)

Ahora tenemos dos ramas (master y feature-branch) con diferentes historiales de confirmación. La rama master tiene las dos primeras confirmaciones, y la rama feature-branch tiene esas dos confirmaciones más la nueva confirmación que acabamos de hacer.

Usemos git diff para ver las diferencias entre la rama master y la rama feature-branch.

git diff master feature-branch

La salida mostrará las líneas exactas que son diferentes entre las dos ramas:

diff --git a/message.txt b/message.txt
index a1b2c3d..e4f5g6h 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+Adding a line on the feature branch.

Esta salida muestra que el archivo message.txt es diferente. La línea que comienza con + indica una línea que se agregó en la rama feature-branch en comparación con la rama master.

Usar git diff es increíblemente poderoso para entender exactamente qué cambios se han realizado entre diferentes versiones de tu proyecto o entre diferentes ramas. Te ayuda a revisar los cambios antes de fusionarlos y a identificar dónde se produjeron modificaciones específicas.

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

Verificar con git merge-base

En este paso, exploraremos el comando git merge-base. Este comando es útil para encontrar el mejor ancestro común entre dos confirmaciones (commits). Piénsalo como encontrar el punto en el tiempo en el que dos líneas temporales (ramas) diferentes se separaron.

Primero, asegúrate de estar en el directorio de tu proyecto:

cd ~/project/my-time-machine

Tenemos dos ramas, master y feature-branch. La rama feature-branch se creó a partir de master, y luego se agregó una nueva confirmación a feature-branch. El ancestro común de estas dos ramas es la confirmación en master justo antes de que se creara feature-branch.

Usemos git merge-base para encontrar el ancestro común de master y feature-branch:

git merge-base master feature-branch

La salida de este comando será el identificador de confirmación del ancestro común. Este debería ser el identificador de confirmación de la segunda confirmación que hicimos en la rama master antes de crear la rama feature-branch.

Salida de ejemplo:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9

(El identificador de confirmación real será diferente en tu caso).

Para verificar que este es realmente el ancestro común, puedes usar git log --oneline para ver la historia de ambas ramas y confirmar visualmente el identificador de confirmación.

git log --oneline --graph --all

Este comando mostrará una representación gráfica de tu historial de confirmaciones en todas las ramas. Puedes retroceder desde los extremos de master y feature-branch para encontrar dónde convergen sus historias. El identificador de confirmación identificado por git merge-base debería ser ese punto de convergencia.

Comprender el ancestro común es importante en Git, especialmente cuando estás preparando para fusionar ramas. Git utiliza el ancestro común para determinar los cambios que deben combinarse.

Resumen

En este laboratorio (lab), aprendimos cómo verificar si una rama (branch) de Git está sincronizada con otra rama utilizando varios comandos de Git. Comenzamos utilizando git log para comparar confirmaciones (commits) entre ramas, entendiendo cómo ver el historial de confirmaciones e identificar diferencias utilizando la sintaxis de rangos. Esto nos permitió ver qué confirmaciones existen en una rama pero no en la otra.

A continuación, exploramos el comando git diff para examinar las diferencias reales en el contenido entre ramas, viendo los cambios línea por línea. Finalmente, usamos git merge-base para encontrar la confirmación del ancestro común de dos ramas, lo que ayuda a determinar si una rama está completamente incluida en la otra. Estos pasos proporcionan un enfoque integral para verificar la sincronización de ramas en Git.