Introducción
En este laboratorio, aprenderás a manejar un escenario común de Git: cuando tu rama local está por delante del repositorio remoto. Esta situación ocurre cuando realizas commits localmente pero aún no los has subido (pushed) al repositorio remoto. Al finalizar este laboratorio, comprenderás cómo identificar cuándo tu rama está por delante del remoto y cómo sincronizar tus repositorios local y remoto correctamente.
Realizando Cambios Locales
En este paso, realizarás cambios en tu repositorio local que aún no han sido subidos (pushed) al repositorio remoto, creando así el escenario de "adelantado a origin".
Configuración del Repositorio
Primero, necesitamos configurar un repositorio con el que podamos trabajar. Usaremos el repositorio git-playground como punto de partida. Dado que necesitas permisos de push para completar este laboratorio, primero deberás hacer un fork del repositorio.
Creación de un Fork del Repositorio
- Visita https://github.com/labex-labs/git-playground en tu navegador
- Haz clic en el botón "Fork" en la esquina superior derecha para crear tu propia copia del repositorio
- Una vez hecho el fork, anota tu nombre de usuario de GitHub; lo necesitarás para el siguiente paso
Clonando Tu Repositorio con Fork
Ahora, clonemos tu repositorio con fork a tu máquina local. Reemplaza YOUR_USERNAME con tu nombre de usuario real de GitHub:
cd ~/project
git clone https://github.com/YOUR_USERNAME/git-playground.git
cd git-playground
Después de clonar, verifica que el repositorio remoto esté configurado correctamente:
git remote -v
Deberías ver una salida que muestre tu repositorio con fork como el remoto origin:
origin https://github.com/YOUR_USERNAME/git-playground.git (fetch)
origin https://github.com/YOUR_USERNAME/git-playground.git (push)
Entendiendo los Repositorios Local y Remoto
Git opera con un modelo distribuido donde cada desarrollador tiene una copia completa del repositorio en su máquina local. Los cambios realizados localmente deben sincronizarse explícitamente con el repositorio remoto.
Ahora, revisemos el estado actual de nuestro repositorio:
git status
Deberías ver una salida similar a esta:
On branch master
Your branch is up to date with 'origin/master'.
nothing to commit, working tree clean
Esto significa que tu repositorio local está actualmente sincronizado con el repositorio remoto.
Creando un Archivo Nuevo
Creemos un archivo nuevo en nuestro repositorio:
echo "This is a new file for our project." > new_file.txt
Después de crear el archivo, necesitamos agregarlo al área de preparación (staging area) de Git:
git add new_file.txt
Ahora, confirmemos (commit) este archivo en nuestro repositorio local:
git commit -m "Add new_file.txt"
Deberías ver una salida confirmando tu commit:
[master 1a2b3c4] Add new_file.txt
1 file changed, 1 insertion(+)
create mode 100644 new_file.txt
Verificando el Estado de la Rama
Ahora que hemos realizado un commit local, revisemos el estado de nuestro repositorio nuevamente:
git status
Esta vez, deberías ver:
On branch master
Your branch is ahead of 'origin/master' by 1 commit.
(use "git push" to publish your local commits)
nothing to commit, working tree clean
Este mensaje indica que tu rama local tiene un commit que aún no ha sido subido (pushed) al repositorio remoto. Esta es exactamente la situación que queríamos crear: tu rama ahora está "adelantada a origin" (ahead of origin).
Visualización de Diferencias de Ramas
Ahora que tu rama local está por delante de la rama remota, exploremos cómo ver las diferencias específicas entre tus ramas local y remota.
Entendiendo las Referencias de Rama
En Git, te refieres a la rama remota usando el formato origin/nombre-de-rama. El término origin es el nombre predeterminado para el repositorio remoto, y nombre-de-rama es el nombre de la rama (en nuestro caso, es master).
Visualización de Diferencias de Commits
Para ver los commits que existen en tu rama local pero no en la rama remota, usa el siguiente comando:
git log origin/master..HEAD
La salida te mostrará el (los) commit(s) que están en tu rama local (HEAD) pero no en la rama remota (origin/master):
commit 1a2b3c4d... (HEAD -> master)
Author: LabEx User <labex@example.com>
Date: ...
Add new_file.txt
Visualización de Diferencias de Archivos
Para ver qué archivos difieren entre tus ramas local y remota, usa:
git diff --name-status origin/master..HEAD
La salida debería mostrar:
A new_file.txt
Esto indica que new_file.txt fue agregado en tu rama local pero no existe en la rama remota.
Entendiendo la Visualización de Diferencias
Para ver las diferencias de contenido reales, puedes usar:
git diff origin/master..HEAD
Esto mostrará los cambios específicos realizados en cada archivo:
diff --git a/new_file.txt b/new_file.txt
new file mode 100644
index 0000000..3b2aed8
--- /dev/null
+++ b/new_file.txt
@@ -0,0 +1 @@
+This is a new file for our project.
Estos comandos te ayudan a entender exactamente qué cambios están en tu rama local que aún no han sido subidos (pushed) al repositorio remoto.
Subiendo Cambios al Remoto
Ahora que entiendes qué cambios están presentes en tu rama local, es hora de sincronizar tu repositorio local con el repositorio remoto subiendo (pushing) tus cambios.
Entendiendo Git Push
El comando git push envía tus commits locales al repositorio remoto. Cuando haces push, sincronizas la rama remota con tu rama local, haciendo que ambas ramas sean idénticas.
Subiendo Tus Cambios
Para subir tus commits locales al repositorio remoto, usa:
git push origin master
Deberías ver una salida similar a esta:
Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 2 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 324 bytes | 324.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/YOUR_USERNAME/git-playground.git
abcd123..1a2b3c4 master -> master
La salida muestra:
- Git contó y comprimió los objetos en tu commit
- Los cambios se enviaron exitosamente al repositorio remoto
- Los identificadores hash del commit antiguo y el nuevo
- La rama que fue actualizada (
master -> master)
Verificando el Push
Revisemos el estado de nuestro repositorio nuevamente:
git status
Ahora deberías ver:
On branch master
Your branch is up to date with 'origin/master'.
nothing to commit, working tree clean
Esto confirma que tu rama local ahora está sincronizada con la rama remota. El mensaje "adelantado a origin" ha desaparecido porque ambas ramas ahora contienen los mismos commits.
Verificando el Contenido del Repositorio Remoto
Podemos verificar que nuestros cambios están ahora en el repositorio remoto examinando el log de la rama remota:
git log origin/master -1
Este comando muestra el commit más reciente en la rama remota, el cual ahora debería incluir nuestro nuevo archivo:
commit 1a2b3c4d... (HEAD -> master, origin/master)
Author: LabEx User <labex@example.com>
Date: ...
Add new_file.txt
Observa que tanto HEAD -> master como origin/master apuntan al mismo commit ahora, confirmando que ambas ramas están sincronizadas.
Creación y Resolución de Múltiples Commits Adelantados
En escenarios del mundo real, podrías tener múltiples commits por delante de tu rama remota. Creemos esta situación y aprendamos cómo resolverla.
Realizando Múltiples Commits Locales
Creemos y confirmemos varios cambios:
## Create a second file
echo "This is the second file." > second_file.txt
git add second_file.txt
git commit -m "Add second_file.txt"
## Modify the README
echo "### Additional Information" >> README.md
echo "This project demonstrates Git branch synchronization." >> README.md
git add README.md
git commit -m "Update README with additional information"
Ahora revisemos nuestro estado:
git status
Deberías ver:
On branch master
Your branch is ahead of 'origin/master' by 2 commits.
(use "git push" to publish your local commits)
nothing to commit, working tree clean
Visualizando Diferencias de Múltiples Commits
Veamos qué commits tenemos localmente que no están en el remoto:
git log origin/master..HEAD --oneline
Deberías ver tus dos nuevos commits:
abcd123 Update README with additional information
efgh456 Add second_file.txt
Subiendo Múltiples Commits
Para sincronizar todos tus commits locales con el repositorio remoto, usa el mismo comando de push:
git push origin master
La salida mostrará ambos commits siendo subidos (pushed):
Enumerating objects: 7, done.
Counting objects: 100% (7/7), done.
Delta compression using up to 2 threads
Compressing objects: 100% (4/4), done.
Writing objects: 100% (5/5), 574 bytes | 574.00 KiB/s, done.
Total 5 (delta 1), reused 0 (delta 0), pack-reused 0
To https://github.com/YOUR_USERNAME/git-playground.git
1a2b3c4..abcd123 master -> master
Verificando que Todos los Commits Fueron Subidos
Revisemos nuestro estado nuevamente:
git status
Deberías ver:
On branch master
Your branch is up to date with 'origin/master'.
nothing to commit, working tree clean
Esto confirma que todos tus commits locales han sido subidos exitosamente al repositorio remoto.
Resumen
En este laboratorio, has aprendido a manejar situaciones en las que tu rama local de Git está adelantada con respecto a la rama remota. Has logrado con éxito:
- Crear un commit local que puso tu rama por delante de la rama remota.
- Usar comandos de Git para ver las diferencias específicas entre tus ramas local y remota.
- Subir (push) tus cambios para sincronizar tus repositorios local y remoto.
- Crear múltiples commits localmente y subirlos todos a la vez a la rama remota.
Estas habilidades son esenciales para el flujo de trabajo diario de Git, ya que te ayudan a mantener sincronizados tus repositorios local y remoto, lo cual es crucial para una colaboración efectiva en proyectos de desarrollo de software. Recuerda que mantener tus ramas sincronizadas regularmente ayuda a prevenir conflictos y hace que la colaboración sea más fluida.
