Cómo comprobar si una rama de Git tiene confirmaciones no enviadas

Introducción

En este laboratorio, aprenderás cómo verificar si tu rama local de Git tiene confirmaciones (commits) que aún no se han enviado a un repositorio remoto. Exploraremos diferentes métodos para identificar estas confirmaciones no enviadas, comenzando con el comando git status para ver si tu rama está por delante de la remota.

Luego, aprenderás cómo usar el comando git log con argumentos específicos para enumerar las confirmaciones que están presentes localmente pero no en la rama de seguimiento remota. Finalmente, discutiremos cómo verificar esta información comparando tu rama local con el repositorio remoto. Al final de este laboratorio, estarás equipado con las habilidades para determinar fácilmente si tus cambios locales necesitan ser enviados.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git(("Git")) -.-> git/CollaborationandSharingGroup(["Collaboration and Sharing"]) git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BranchManagementGroup -.-> git/log("Show Commits") git/CollaborationandSharingGroup -.-> git/push("Update Remote") subgraph Lab Skills git/add -.-> lab-560040{{"Cómo comprobar si una rama de Git tiene confirmaciones no enviadas"}} git/status -.-> lab-560040{{"Cómo comprobar si una rama de Git tiene confirmaciones no enviadas"}} git/commit -.-> lab-560040{{"Cómo comprobar si una rama de Git tiene confirmaciones no enviadas"}} git/log -.-> lab-560040{{"Cómo comprobar si una rama de Git tiene confirmaciones no enviadas"}} git/push -.-> lab-560040{{"Cómo comprobar si una rama de Git tiene confirmaciones no enviadas"}} end

Usar `git status` para verificar confirmaciones por delante

En este paso, aprenderemos cómo usar el comando git status para ver si nuestra rama local tiene confirmaciones (commits) que están por delante de la rama remota. Este es un escenario común cuando has realizado cambios localmente y 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. Llamaremos a este archivo future_plans.txt:

echo "Plan for world domination." > future_plans.txt

A continuación, necesitamos preparar este nuevo archivo para una confirmación (staging):

git add future_plans.txt

Ahora, creemos una confirmación con un mensaje que describa nuestro cambio:

git commit -m "Add future plans"

Deberías ver una salida similar a esta, lo que indica que se ha creado una nueva confirmación:

[master abcdefg] Add future plans
 1 file changed, 1 insertion(+)
 create mode 100644 future_plans.txt

Ahora hemos creado una nueva confirmación en nuestra rama local master. Sin embargo, esta confirmación solo existe localmente y no se ha enviado a ningún repositorio remoto.

Usemos git status para ver el estado actual de nuestro repositorio:

git status

La salida ahora debería mostrar que tu rama local está por delante de la rama remota (si tuvieras una configurada, lo cual no es el caso en este ejemplo básico, pero Git aún te da la pista):

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

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   future_plans.txt

nothing to commit, working tree clean

La línea importante aquí es Your branch is ahead of 'origin/master' by 1 commit.. Esto nos dice que nuestra rama local master tiene una confirmación que no está presente en la rama origin/master (que es el nombre predeterminado para la rama remota que espera Git).

Esta es una información muy útil. Te permite saber que tienes cambios locales que aún no se han compartido con otros. En un escenario real con un repositorio remoto, esto indicaría que necesitas usar git push para enviar tus cambios.

Ejecutar `git log --oneline @{u}..HEAD`

En el paso anterior, vimos cómo git status puede decirnos si nuestra rama local está por delante de la rama remota. Ahora, usemos el comando git log con una sintaxis especial para ver exactamente qué confirmaciones (commits) están por delante.

Asegúrate de que todavía estés en el directorio ~/project/my-time-machine.

El comando que usaremos es git log --oneline @{u}..HEAD. Desglosemos este comando:

git log: Este es el comando para ver el historial de confirmaciones.
--oneline: Esta opción muestra cada confirmación en una sola línea, lo que hace que la salida sea concisa y fácil de leer.
@{u}: Esta es una sintaxis especial que se refiere a la rama upstream (rama principal remota). En nuestro caso, dado que no hemos establecido explícitamente una rama upstream, Git usa origin/master por defecto (suponiendo que origin es el nombre del repositorio remoto y master es la rama).
..HEAD: Esta es una notación de rango. HEAD se refiere al final de la rama actual (nuestra rama local master). El rango @{u}..HEAD significa "muéstrame las confirmaciones que son alcanzables desde HEAD pero no desde @{u}". En términos más simples, muestra las confirmaciones que están en nuestra rama local pero no en la rama remota upstream.

Ahora, ejecutemos el comando:

git log --oneline @{u}..HEAD

Deberías ver una salida similar a esta:

abcdefg (HEAD -> master) Add future plans

Esta salida muestra la confirmación que creamos en el paso anterior (Add future plans). El identificador único (abcdefg) será diferente en tu terminal, pero el mensaje de confirmación debe coincidir.

Este comando es increíblemente útil para ver exactamente qué confirmaciones estás a punto de enviar a un repositorio remoto. Te da una lista clara de los cambios que has realizado localmente y que aún no se han compartido.

Comparando esta salida con la salida de git status del paso anterior, puedes ver que git status te dice cuántas confirmaciones estás por delante, mientras que git log @{u}..HEAD te dice qué confirmaciones específicas estás por delante. Ambos comandos proporcionan información valiosa sobre el estado de tu repositorio local en relación con su contraparte remota.

Verificar mediante comparación con el remoto

En un escenario real, normalmente tendrías un repositorio remoto (como en GitHub, GitLab o Bitbucket) al que esté conectado tu repositorio local. En este entorno de laboratorio, no tenemos un repositorio remoto activo al que enviar los cambios. Sin embargo, podemos simular el concepto de comparar nuestra rama local con una rama remota utilizando los comandos que hemos aprendido.

Ya hemos utilizado git status y git log --oneline @{u}..HEAD para ver las confirmaciones (commits) que están en nuestra rama local pero no en la rama upstream simulada (origin/master).

Repasemos de nuevo la salida de git status:

git status

Todavía deberías ver la línea que indica que tu rama está por delante:

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

... (rest of the output)

Y la salida de git log --oneline @{u}..HEAD:

git log --oneline @{u}..HEAD

Esto debería mostrar la única confirmación que hicimos:

abcdefg (HEAD -> master) Add future plans

Estos dos comandos trabajan juntos para darte una imagen clara de la diferencia entre tu rama local y su rama upstream configurada. git status proporciona un resumen, mientras que git log @{u}..HEAD proporciona los detalles de las confirmaciones específicas.

En un proyecto real, después de ver esta salida, normalmente ejecutarías git push para enviar tus confirmaciones locales al repositorio remoto, haciéndolas disponibles para otros y actualizando la rama remota.

Dado que no tenemos un repositorio remoto al que enviar los cambios en este laboratorio, hemos completado con éxito el objetivo de entender cómo identificar las confirmaciones que están por delante de la rama remota utilizando git status y git log.

Esta habilidad es fundamental para colaborar con otros y mantener sincronizados tus repositorios local y remoto. Al comprobar regularmente el estado y el registro, puedes estar al tanto de tus cambios pendientes y asegurarte de enviarlos cuando estés listo.

Resumen

En este laboratorio, aprendimos cómo comprobar si una rama de Git tiene confirmaciones (commits) no enviadas. Comenzamos utilizando el comando git status después de realizar una confirmación local. La salida de git status indica claramente si la rama local está "por delante" de su contraparte remota y por cuántas confirmaciones, proporcionando una forma directa de ver si hay cambios no enviados.

Luego exploramos el uso de git log --oneline @{u}..HEAD para obtener una vista más detallada de las confirmaciones específicas que están en la rama local pero no en la rama de seguimiento remota. Este comando lista los hashes y mensajes de las confirmaciones no enviadas, ofreciendo una forma precisa de identificar qué cambios están pendientes. Finalmente, discutimos el concepto de verificar esto mediante la comparación de las ramas local y remota, reforzando la comprensión de cómo confirmar la presencia de confirmaciones no enviadas.