Cómo verificar si un commit de Git está en una rama específica

Introducción

En este laboratorio, aprenderás cómo determinar si un commit (confirmación) específico de Git existe dentro de una rama (branch) particular. Exploraremos el comando git branch --contains para identificar todas las ramas que incluyen un commit dado, lo que nos dará información sobre la historia del commit y los puntos de integración.

También aprenderás cómo usar git log con el nombre de una rama para verificar la presencia de un commit en la historia de esa rama y cómo comprobar de manera eficiente múltiples ramas en busca de un commit. Este laboratorio te proporcionará las habilidades esenciales para entender y navegar por la historia de tu proyecto de Git.

Ejecutar git branch --contains Commit

En este paso, aprenderemos cómo usar el comando git branch --contains para descubrir qué ramas (branches) contienen un commit (confirmación) específico. Este es un comando muy útil cuando se desea entender la historia de un proyecto y ver dónde se ha integrado un cambio particular.

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

cd ~/project/my-time-machine

Ahora, creemos un nuevo archivo y hagamos un commit. Esto nos dará un nuevo commit con el que trabajar.

echo "Another message for the future" > message2.txt
git add message2.txt
git commit -m "Add another message"

Después del commit, deberías ver una salida similar a esta:

[master <commit-id>] Add another message
 1 file changed, 1 insertion(+)
 create mode 100644 message2.txt

Ahora tenemos un nuevo commit. Encontremos el ID del commit de este nuevo commit. Podemos usar git log --oneline para ver un registro condensado:

git log --oneline

La salida se verá algo así:

<commit-id-2> (HEAD -> master) Add another message
<commit-id-1> Send a message to the future

El primer ID de commit que se muestra es el de "Add another message". Copia este ID de commit.

Ahora, usemos git branch --contains con este ID de commit. Reemplaza <commit-id-2> con el ID de commit real que copiaste:

git branch --contains <commit-id-2>

La salida debería mostrar la rama master, lo que indica que este commit está en la rama master:

* master

El comando git branch --contains <commit> es poderoso porque te ayuda a rastrear la línea de descendencia de un commit. Si tienes múltiples ramas, este comando listará todas las ramas que incluyen ese commit específico. Esto es esencial para entender cómo fluyen los cambios a través de las diferentes líneas de desarrollo de tu proyecto.

Utilizar git log Branch para verificar

En el paso anterior, usamos git branch --contains para ver qué ramas (branches) contienen un commit (confirmación) específico. Ahora, usemos el comando git log con el nombre de una rama para verificar la historia de esa rama. Esto nos mostrará todos los commits que forman parte de la historia de esa rama.

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

cd ~/project/my-time-machine

Sabemos del paso anterior que nuestro último commit está en la rama master. Veamos el registro (log) específicamente de la rama master:

git log master --oneline

Deberías ver una salida similar a esta, que muestra los commits en la rama master:

<commit-id-2> (HEAD -> master) Add another message
<commit-id-1> Send a message to the future

Esta salida confirma que ambos commits están realmente en la rama master. Usar git log <branch-name> es una excelente manera de inspeccionar la historia de una rama específica y ver todos los commits que son alcanzables desde la punta de esa rama.

Comparar la salida de git branch --contains <commit> y git log <branch-name> te ayuda a entender la relación entre commits y ramas. git branch --contains te dice qué ramas incluyen un commit en cualquier parte de su historia, mientras que git log <branch-name> muestra la historia lineal que conduce a la punta de esa rama específica.

Presiona q para salir de la vista del registro.

Verificar múltiples ramas

En este paso, crearemos una nueva rama y veremos cómo se comporta git branch --contains cuando un commit está presente en múltiples ramas. Esto ilustrará aún más el poder de este comando para entender la estructura de ramificación de tu proyecto.

Primero, asegúrate de estar en el directorio ~/project/my-time-machine:

cd ~/project/my-time-machine

Ahora, creemos una nueva rama llamada feature-branch:

git branch feature-branch

Este comando crea una nueva rama, pero no te cambia a ella. Todavía estás en la rama master.

Verifiquemos nuestras ramas:

git branch

Deberías ver ambas ramas listadas, con master resaltada (lo que indica que es la rama actual):

* master
  feature-branch

Ahora, obtengamos nuevamente el ID del commit de nuestro último commit usando git log --oneline:

git log --oneline

La salida será similar a la anterior:

<commit-id-2> (HEAD -> master, feature-branch) Add another message
<commit-id-1> Send a message to the future

Observa que el último commit ahora muestra tanto HEAD -> master como feature-branch. Esto significa que la rama feature-branch se creó en este commit.

Ahora, usemos git branch --contains nuevamente con este ID de commit. Reemplaza <commit-id-2> con el ID de commit real:

git branch --contains <commit-id-2>

Esta vez, la salida debería mostrar ambas ramas, porque el commit existe en la historia tanto de master como de feature-branch:

* master
  feature-branch

Esto demuestra cómo git branch --contains puede mostrarte todas las ramas que tienen un commit particular en su historia. Esto es increíblemente útil para rastrear dónde se han fusionado o integrado cambios a lo largo de diferentes líneas de desarrollo.

Resumen

En este laboratorio (lab), aprendimos cómo verificar si un commit de Git está presente en una rama específica. Comenzamos utilizando el comando git branch --contains <commit-id>, que lista todas las ramas (branches) que incluyen el commit especificado. Esta es una herramienta fundamental para entender la historia y la integración de cambios dentro de un repositorio de Git.

Luego exploramos cómo verificar la presencia de un commit en una rama utilizando git log <branch-name>. Este comando muestra el historial de commits de una rama específica, lo que nos permite confirmar visualmente si el commit objetivo forma parte de la línea de ancestros de esa rama. Finalmente, vimos cómo extender estas técnicas para buscar un commit en múltiples ramas, lo que proporciona una visión integral de su distribución dentro de la estructura de ramificación del proyecto.