Cómo comprobar si una rama de Git está detrás de la rama remota

Introducción

En este laboratorio, aprenderás cómo determinar si tu rama local de Git está atrasada con respecto a su rama remota correspondiente. Cubriremos los pasos esenciales para lograr esto, comenzando por obtener los últimos cambios del repositorio remoto utilizando git fetch.

Después de obtener los cambios, utilizarás git status para comprobar rápidamente si tu rama está atrasada con respecto a la remota. Finalmente, aprenderás cómo usar git log HEAD..@{u} para ver los commits específicos que existen en la rama remota pero no en tu rama local, lo que te proporcionará una comprensión detallada de las diferencias.

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/BranchManagementGroup -.-> git/log("Show Commits") git/CollaborationandSharingGroup -.-> git/fetch("Download Updates") git/CollaborationandSharingGroup -.-> git/pull("Update & Merge") git/CollaborationandSharingGroup -.-> git/remote("Manage Remotes") subgraph Lab Skills git/status -.-> lab-560042{{"Cómo comprobar si una rama de Git está detrás de la rama remota"}} git/log -.-> lab-560042{{"Cómo comprobar si una rama de Git está detrás de la rama remota"}} git/fetch -.-> lab-560042{{"Cómo comprobar si una rama de Git está detrás de la rama remota"}} git/pull -.-> lab-560042{{"Cómo comprobar si una rama de Git está detrás de la rama remota"}} git/remote -.-> lab-560042{{"Cómo comprobar si una rama de Git está detrás de la rama remota"}} end

Obtener cambios remotos con git fetch

En este paso, aprenderemos cómo obtener cambios de un repositorio remoto de Git. Imagina que estás colaborando con otros y ellos han realizado cambios en el proyecto. git fetch es el comando que se utiliza para descargar esos cambios a tu máquina local sin fusionarlos con tu trabajo actual.

Primero, simulemos tener un repositorio remoto. Crearemos uno simple localmente con fines demostrativos.

cd ~/project
mkdir remote-repo
cd remote-repo
git init --bare

Esto crea un repositorio "desnudo" (bare), que se utiliza típicamente como un repositorio remoto central. Ahora, volvamos a nuestro repositorio my-time-machine y agreguemos este como remoto.

cd ~/project/my-time-machine
git remote add origin ../remote-repo

Hemos agregado un remoto llamado origin que apunta a nuestro repositorio remoto simulado. Ahora, hagamos un cambio en el repositorio remoto y luego obtengámoslo.

cd ~/project/remote-repo
echo "This is a remote change." > remote_file.txt
git add remote_file.txt
git commit -m "Add remote file"

Ahora, volviendo a nuestro repositorio my-time-machine, obtengamos los cambios del remoto.

cd ~/project/my-time-machine
git fetch origin

Deberías ver una salida que indique que Git ha descargado los cambios del repositorio remoto. Algo como esto:

remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 2 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (2/2), 258 bytes | 258.00 KiB | elapsed 0.00s.
From ../remote-repo
 * [new branch]      master     -> origin/master

El comando git fetch descarga los commits, archivos y referencias del repositorio remoto a tu repositorio local. Sin embargo, no fusiona automáticamente estos cambios en tu rama de trabajo actual. Esto te permite inspeccionar los cambios antes de integrarlos.

Puedes pensar en git fetch como obtener las últimas actualizaciones de un feed de noticias. Ves los títulos y resúmenes, pero aún no has leído los artículos completos. Puedes decidir qué artículos (cambios) quieres leer (fusionar) más tarde.

Usar git status para comprobar el estado de retraso

En el paso anterior, obtuvimos los cambios del repositorio remoto. Ahora, usemos git status para ver cómo se compara nuestro repositorio local con el remoto.

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

cd ~/project/my-time-machine

Ahora, ejecuta el comando git status:

git status

Deberías ver una salida similar a esta:

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

Esta salida nos dice algunas cosas importantes:

"On branch master": Actualmente estamos en la rama master.
"Your branch is behind 'origin/master' by 1 commit": ¡Este es el mensaje clave! Indica que nuestra rama local master está un commit detrás de la rama master en el remoto origin. Esto significa que hay un commit en el remoto que aún no tenemos localmente.
"(use "git pull" to update your local branch)": Git incluso nos da una pista sobre cómo actualizar nuestra rama local.

El comando git status es tu ventana al estado de tu repositorio. Te dice en qué rama estás, si tienes cambios no confirmados y cómo se compara tu rama actual con su rama upstream (en este caso, origin/master).

Comprender la salida de git status es crucial para trabajar de manera efectiva con Git. Te ayuda a saber si necesitas obtener cambios del remoto, si tienes cambios para confirmar o si tu directorio de trabajo está limpio.

Ejecutar git log HEAD..@{u} para ver los commits de retraso

En el paso anterior, git status nos indicó que nuestra rama local está detrás de la rama remota. Pero, ¿cómo podemos ver qué commits nos faltan?

Podemos usar el comando git log con una sintaxis especial para mostrar solo los commits que están en la rama remota pero no en nuestra rama local. La sintaxis HEAD..@{u} compara nuestra rama actual (HEAD) con su rama upstream (@{u}, que en nuestro caso es origin/master).

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

cd ~/project/my-time-machine

Ahora, ejecuta el siguiente comando:

git log HEAD..@{u}

Deberías ver la entrada del log para el commit que hicimos en el repositorio remoto en el Paso 1:

commit <commit-hash> (origin/master)
Author: Your Name <[email protected]>
Date:   <Date and Time>

    Add remote file

Este comando es muy útil para ver exactamente qué cambios obtendrás cuando realices un pull desde el remoto. Muestra el historial de commits que está presente en la rama de seguimiento remota (origin/master) pero aún no en tu rama local (master).

Comprender cómo ver los commits de los que estás detrás es importante para mantenerse actualizado con el trabajo de tus colaboradores y para planificar tus fusiones.

Presiona q para salir de la vista del log.

Resumen

En este laboratorio, aprendimos cómo comprobar si una rama local de Git está detrás de su contraparte remota. Comenzamos simulando un repositorio remoto y lo agregamos a nuestro proyecto local utilizando git remote add. Luego, practicamos el uso de git fetch para descargar los cambios del remoto sin fusionarlos, demostrando cómo este comando actualiza nuestro repositorio local con la información remota más reciente.

Después de la recuperación (fetch), normalmente usaríamos git status para ver si nuestra rama actual está detrás de la rama de seguimiento remota y git log HEAD..@{u} para ver los commits específicos que están presentes en el remoto pero aún no en nuestra rama local. Estos pasos en conjunto brindan una imagen clara de la divergencia entre nuestro trabajo local y el repositorio remoto.