Git intermedio: trabajo con ramas remotas y rebase

Git es una herramienta poderosa, pero una vez dominados los conceptos básicos, el día a día implica escenarios más complejos: colaboración en equipo, limpieza de historial y actualización constante del código local. Este tutorial cubre el nivel intermedio que todo desarrollador debería tener en su arsenal.

1. Sincronizar tu rama local con el repositorio remoto

Cuando trabajas en una rama de features y otros han enviado cambios, tu copia local se queda desactualizada. El flujo habitual es:

$ git fetch origin
$ git status
$ git rebase origin/main

git fetch descarga los cambios sin fusionarlos inmediatamente. git rebase origin/main coloca tus commits encima de la última versión del branch remoto, manteniendo un historial lineal. Si prefieres fusionar en lugar de rebase, sustituye el último comando por git merge origin/main.

2. Eliminar ramas remotas ya fusionadas

Con el tiempo, el repositorio se llena de ramas que ya no hacen falta. Para limpiarlas de forma segura:

$ git fetch --prune origin
$ git branch -r --merged origin/main | grep -v main | xargs -I {} git push origin --delete {}

El --prune hace que fetch elimine las referencias a commits que ya no existen en el remoto. El segundo comando lista las ramas remotas que ya fueron fusionadas a main y las elimina con un solo push --delete.

3. Reescribir el historial con git commit --amend

A menudo cometes un error pequeño en el mensaje o olvidas incluir un archivo en el commit anterior. En lugar de crear un nuevo commit, usa amend:

$ git commit --amend

Esto abre tu editor de texto con el mensaje anterior. Modifícalo y guarda — el commit quedará reemplazo, sin alterar el historial público (solo si la rama es local o aún no ha sido enviada al repositorio remoto).

4. Rebasing interactivo para limpiar commits

Si has hecho varios commits pequeños y quieres combinarlos en uno solo antes de compartir la rama, el rebase interactivo es la herramienta:

$ git rebase -i HEAD~4

Se abrirá una lista de los 4 últimos commits con la palabra pick al lado. Cambia pick por squash o fixup para unirlos. squash te pedirá un nuevo mensaje que combine los dos; fixup conserva el mensaje del primero y descarta el segundo.

5. Trabajar con remotes de upstream en forks

Si tienes un fork y quieres contribuir a un repositorio original:

$ git remote add upstream https://github.com/original/repo.git
$ git fetch upstream
$ git checkout -b feature-branch upstream/main

Ahora puedes hacer cambios, enviarlos a tu fork con git push origin feature-branch y abrir un Pull Request contra el repositorio original.

6. Solucionar conflictos de merge y rebase

Los conflictos son inevitables cuando varios personas tocan las mismas líneas. Cuando git se detiene y te pide resolverlos:

1. Abre los archivos marcados con <<<<<<<, =======, >>>>>>>
2. Edita el contenido para mantener lo que quieres conservar
3. git add <archivo> para marcar como resuelto
4. git rebase --continue (o git merge --continue) para continuar

Consejo: si el conflicto es muy complejo, git mergetool lanzará tu visualizador de diferencias favorito.

7. Consejos adicionales de productividad

• git log --oneline --graph --all — visualiza el árbol de commits en forma de gráfico
• git stash — guarda cambios temporales para cambiar de rama sin hacer commit
• git diff --cached — muestra qué está en el staging area (área de preparación)
• git restore --source <commit> <archivo> — restaura un archivo de un commit anterior sin afectar el working tree completo

8. Ejemplo práctico: actualizar tu feature branch

Supongamos que creaste feature-nova desde main hace una semana. Hoy hay nuevos commits en main. Para actualizar tu rama sin un merge commit inútil:

$ git checkout feature-nova
$ git rebase main

Si hay conflictos, resuélvelos y ejecuta git rebase --continue hasta que termine. Tu historial quedará limpio, como si hubieras creado la rama hoy mismo.

Resumen rápido