Cómo comprobar si un commit de Git está en la rama actual

Introducción

En este laboratorio, aprenderás cómo determinar si un commit específico de Git existe dentro de la rama actual. Comenzaremos explorando el comando git log y sus diversas opciones para buscar y filtrar de manera eficiente el historial de commits, incluyendo el uso de --grep para buscar en los mensajes de commit y --author para filtrar por autor.

A continuación, aprenderás cómo usar el comando git branch --contains para identificar qué ramas en tu repositorio incluyen un commit dado. Este ejercicio práctico te proporcionará las habilidades necesarias para navegar y entender de manera efectiva el historial de commits de tu proyecto en diferentes ramas.

Skills Graph

Usar git log para encontrar commits

En este paso, aprenderemos cómo usar el comando git log para encontrar commits específicos en el historial de nuestro proyecto. A medida que tu proyecto crece y realizas más commits, la salida de git log puede volverse bastante larga. Git proporciona opciones poderosas para filtrar y buscar en el registro.

Primero, hagamos algunos commits más para tener un historial con el que trabajar. Asegúrate de estar en el directorio ~/project/my-time-machine.

cd ~/project/my-time-machine
echo "Adding a second message" >> message.txt
git add message.txt
git commit -m "Add a second message"
echo "Adding a third message" >> message.txt
git add message.txt
git commit -m "Add a third message"

Ahora, veamos el registro completo nuevamente:

git log

Verás tres commits listados, con el más reciente en la parte superior.

A veces, es posible que estés buscando un commit que contenga una palabra específica en su mensaje. Puedes usar la opción --grep para esto. Busquemos el commit con "second message":

git log --grep "second message"

Este comando solo mostrará el commit cuyo mensaje contiene la frase "second message".

Otra opción útil es --author para encontrar commits de un autor específico. Dado que configuramos nuestro nombre de autor en la configuración inicial, intentemos encontrar commits de "Jane Doe":

git log --author "Jane Doe"

Esto mostrará todos los commits realizados por "Jane Doe".

Finalmente, puedes limitar el número de commits mostrados usando la opción -n. Por ejemplo, para ver solo los últimos dos commits:

git log -n 2

Usar estas opciones con git log te ayuda a navegar por el historial de tu proyecto de manera eficiente, especialmente en proyectos más grandes con muchos commits.

Ejecutar git branch --contains para un commit

En este paso, exploraremos cómo usar el comando git branch --contains. Este comando es útil para descubrir qué ramas contienen un commit específico. Esto es especialmente útil cuando tienes múltiples ramas y necesitas rastrear dónde se ha incluido un cambio determinado.

Primero, obtengamos el hash del commit de uno de nuestros commits anteriores. Podemos usar git log --oneline para ver una vista condensada del registro y copiar fácilmente un hash de commit. Asegúrate de estar en el directorio ~/project/my-time-machine.

cd ~/project/my-time-machine
git log --oneline

Verás una salida similar a esta (tus hashes de commit serán diferentes):

abcdefg (HEAD -> master) Add a third message
hijklmn Add a second message
opqrstu Send a message to the future

Copia el hash del commit del primer commit que hiciste ("Send a message to the future"). En el ejemplo anterior, es opqrstu.

Ahora, usemos git branch --contains con este hash de commit. Reemplaza [commit_hash] con el hash real que copiaste:

git branch --contains [commit_hash]

Por ejemplo, usando el hash de la salida del ejemplo:

git branch --contains opqrstu

La salida debería mostrar * master. El asterisco * indica la rama actualmente seleccionada. Esto nos dice que el commit opqrstu está presente en la rama master.

En este momento, solo tenemos una rama (master), por lo que la salida es simple. En el siguiente paso, crearemos otra rama y veremos cómo cambia la salida de git branch --contains.

Comprender qué ramas contienen un commit específico es crucial para gestionar el historial de tu proyecto y coordinar el trabajo en diferentes líneas de desarrollo.

Probar con otras ramas

En este paso, crearemos una nueva rama y realizaremos un commit en ella para ver cómo se comporta git branch --contains cuando un commit solo está en una rama. Esto ayudará a consolidar tu comprensión de cómo Git rastrea los commits en diferentes líneas de desarrollo.

Primero, creemos una nueva rama llamada feature-branch. Asegúrate de estar en el directorio ~/project/my-time-machine.

cd ~/project/my-time-machine
git branch feature-branch

Ahora, cambiemos a nuestra nueva rama:

git checkout feature-branch

Deberías ver una salida que indique que has cambiado a la nueva rama:

Switched to branch 'feature-branch'

Realicemos un nuevo commit en esta feature-branch.

echo "Adding a feature" >> feature.txt
git add feature.txt
git commit -m "Add a new feature file"

Ahora, obtengamos el hash del commit de este nuevo commit usando git log --oneline:

git log --oneline

La salida mostrará tu nuevo commit en la parte superior, seguido de los commits anteriores. Copia el hash del commit "Add a new feature file".

Ahora, usemos git branch --contains con el hash del commit "Add a new feature file". Reemplaza [feature_commit_hash] con el hash real que copiaste:

git branch --contains [feature_commit_hash]

La salida debería mostrar solo * feature-branch. Esto se debe a que este commit específico se realizó después de crear y cambiar a feature-branch, por lo que solo existe en el historial de esta rama.

Ahora, intentemos git branch --contains con el hash del primer commit ("Send a message to the future") nuevamente. Reemplaza [first_commit_hash] con el hash que usaste en el paso anterior:

git branch --contains [first_commit_hash]

Esta vez, la salida debería mostrar tanto feature-branch como * master. Esto se debe a que la feature-branch se creó a partir de la rama master, por lo que contiene todos los commits que estaban en master en ese momento, incluyendo el primer commit.

Esto demuestra cómo git branch --contains puede ayudarte a entender la relación entre las ramas y los commits que incluyen.

Resumen

En este laboratorio, aprendimos cómo verificar si un commit de Git está presente en la rama actual. Comenzamos explorando el comando git log y sus diversas opciones como --grep, --author y -n para buscar y filtrar de manera eficiente el historial de commits. Esto es crucial para navegar por proyectos con numerosos commits.

Luego, aprendimos cómo usar el comando git branch --contains para identificar qué ramas incluyen un commit específico. Este comando es valioso para rastrear la propagación de cambios a través de diferentes ramas dentro de un repositorio de Git.