Ramas en Git (Branches)

Módulo 4: Ramas en Git (Branches)

Las ramas son una de las características más poderosas de Git. Te permiten desarrollar funcionalidades, experimentar y colaborar sin afectar el código principal. En este módulo dominarás el trabajo con ramas.

¿Qué es una rama?

Una rama en Git es una línea independiente de desarrollo. Es como crear una copia del proyecto donde puedes hacer cambios sin afectar la rama principal.

main:     A---B---C---F---G
               \         /
feature:        D---E---/

A, B, C, D, E, F, G = commits
main = rama principal
feature = rama de funcionalidad

Ventajas de las ramas:

Desarrollo paralelo
Experimentación segura
Organización del trabajo
Colaboración eficiente

Crear, cambiar y eliminar ramas

Comandos básicos de ramas

# Ver todas las ramas
git branch

# Ver ramas incluyendo remotas
git branch -a

# Ver ramas con último commit
git branch -v

# Crear nueva rama
git branch nueva-funcionalidad

# Crear y cambiar a nueva rama
git checkout -b nueva-funcionalidad

# Cambiar a rama existente
git checkout main

# Crear rama desde commit específico
git checkout -b hotfix abc1234

Gestión avanzada de ramas

# Renombrar rama actual
git branch -m nuevo-nombre

# Renombrar rama específica
git branch -m viejo-nombre nuevo-nombre

# Eliminar rama (debe estar fusionada)
git branch -d rama-terminada

# Forzar eliminación de rama
git branch -D rama-experimental

# Eliminar rama remota
git push origin --delete rama-remota

# Ver ramas fusionadas
git branch --merged

# Ver ramas no fusionadas
git branch --no-merged

Trabajar con ramas remotas

# Ver ramas remotas
git branch -r

# Crear rama local desde remota
git checkout -b local-branch origin/remote-branch

# Configurar rama local para seguir remota
git branch --set-upstream-to=origin/main main

# Push de nueva rama al remoto
git push -u origin nueva-rama

# Sincronizar ramas remotas
git fetch --prune

Fusionar ramas (git merge)

Fusionar es el proceso de integrar cambios de una rama en otra.

Tipos de merge

Fast-forward merge
Three-way merge

Antes del merge:
main:     A---B---C
               \
feature:        D---E

Después del merge:
main:     A---B---C---D---E

# Fast-forward automático
git checkout main
git merge feature

# Forzar fast-forward (falla si no es posible)
git merge --ff-only feature

# Evitar fast-forward (crear commit de merge)
git merge --no-ff feature

Antes del merge:
main:     A---B---C---F
               \     /
feature:        D---E

Después del merge:
main:     A---B---C---F---M
               \         /
feature:        D---E---/

M = commit de merge

# Three-way merge (automático)
git checkout main
git merge feature

# Merge con mensaje personalizado
git merge feature -m "Merge feature: nueva funcionalidad"

Estrategias de merge

# Merge normal (estrategia por defecto)
git merge feature

# Merge recursivo (para casos complejos)
git merge -s recursive feature

# Merge octopus (múltiples ramas)
git merge rama1 rama2 rama3

# Merge sin commit automático
git merge --no-commit feature

# Merge solo si es fast-forward
git merge --ff-only feature

Resolver conflictos de fusión

Los conflictos ocurren cuando Git no puede fusionar automáticamente los cambios.

Identificar conflictos

# Intentar merge
git merge feature

# Si hay conflictos, Git mostrará:
# Auto-merging archivo.txt
# CONFLICT (content): Merge conflict in archivo.txt
# Automatic merge failed; fix conflicts and then commit the result.

# Ver archivos con conflictos
git status

# Ver diferencias de conflicto
git diff

Resolver conflictos manualmente

Abrir archivos con conflictos

# Los conflictos se marcan así:
<<<<<<< HEAD
Código de la rama actual (main)
=======
Código de la rama que se está fusionando (feature)
>>>>>>> feature

Editar el archivo
- Eliminar marcadores de conflicto (<<<<<<<, =======, >>>>>>>)
- Decidir qué código mantener
- Combinar cambios si es necesario

Marcar como resuelto

# Después de editar el archivo
git add archivo-resuelto.txt

# Verificar estado
git status

Completar el merge

# Commit del merge
git commit

# O abortar el merge
git merge --abort

Herramientas para resolver conflictos

# Configurar herramienta de merge
git config --global merge.tool vimdiff
git config --global merge.tool meld
git config --global merge.tool vscode

# Usar herramienta de merge
git mergetool

# Ver configuración actual
git config --get merge.tool

Flujo típico con ramas: main, dev, feature

Un flujo de trabajo bien estructurado mejora la organización y reduce conflictos.

Git Flow - Flujo tradicional

Estructura de ramas
Comandos Git Flow

main:      A---B---C---F---H---J
                \     /     \   /
develop:         D---E---G---I
                  \     /
feature:           X---Y

Ramas principales:

main: Código en producción
develop: Integración de funcionalidades

Ramas de soporte:

feature/*: Nuevas funcionalidades
hotfix/*: Correcciones urgentes
release/*: Preparación de versiones

# Inicializar Git Flow
git flow init

# Crear feature branch
git flow feature start nueva-funcionalidad

# Finalizar feature
git flow feature finish nueva-funcionalidad

# Crear release branch
git flow release start v1.0.0

# Finalizar release
git flow release finish v1.0.0

# Crear hotfix
git flow hotfix start correccion-urgente

# Finalizar hotfix
git flow hotfix finish correccion-urgente

GitHub Flow - Flujo simplificado

# 1. Crear rama desde main
git checkout main
git pull origin main
git checkout -b feature/nueva-funcionalidad

# 2. Desarrollar funcionalidad
git add .
git commit -m "feat: implementar nueva funcionalidad"
git push -u origin feature/nueva-funcionalidad

# 3. Crear Pull Request en GitHub

# 4. Después del merge, limpiar
git checkout main
git pull origin main
git branch -d feature/nueva-funcionalidad
git push origin --delete feature/nueva-funcionalidad

Flujo personalizado recomendado

Rama main: Código estable en producción

# main siempre debe estar estable
# Solo se actualiza mediante Pull Requests
# Protegida contra push directo

Ramas feature: Una por funcionalidad

# Nomenclatura descriptiva
git checkout -b feature/sistema-login
git checkout -b feature/dashboard-usuario
git checkout -b bugfix/corregir-validacion

Ramas hotfix: Correcciones urgentes

# Para correcciones críticas en producción
git checkout -b hotfix/seguridad-critica
# Se fusiona tanto en main como en develop

Ejemplos prácticos completos

Ejemplo 1: Desarrollar nueva funcionalidad

Preparar entorno

# Asegurar que main está actualizado
git checkout main
git pull origin main

# Crear rama para funcionalidad
git checkout -b feature/sistema-comentarios

Desarrollar funcionalidad

# Crear archivos necesarios
touch comentarios.js comentarios.css

# Implementar funcionalidad
echo "// Sistema de comentarios" > comentarios.js
echo "/* Estilos para comentarios */" > comentarios.css

# Hacer commits incrementales
git add comentarios.js
git commit -m "feat: agregar lógica de comentarios"

git add comentarios.css
git commit -m "style: agregar estilos para comentarios"

Sincronizar con main

# Cambiar a main y actualizar
git checkout main
git pull origin main

# Volver a feature y rebase
git checkout feature/sistema-comentarios
git rebase main

Subir y crear PR

# Push de la rama
git push -u origin feature/sistema-comentarios

# Crear Pull Request en GitHub
# Después del merge, limpiar
git checkout main
git pull origin main
git branch -d feature/sistema-comentarios

Ejemplo 2: Resolver conflictos

Simular conflicto

# En main
git checkout main
echo "Versión main" > archivo.txt
git add archivo.txt
git commit -m "Actualizar archivo en main"

# En feature
git checkout -b feature/conflicto
echo "Versión feature" > archivo.txt
git add archivo.txt
git commit -m "Actualizar archivo en feature"

Intentar merge

git checkout main
git merge feature/conflicto
# CONFLICT (content): Merge conflict in archivo.txt

Resolver conflicto

# Ver contenido del archivo
cat archivo.txt
# <<<<<<< HEAD
# Versión main
# =======
# Versión feature
# >>>>>>> feature/conflicto

# Editar archivo para resolver
echo "Versión combinada main + feature" > archivo.txt

# Marcar como resuelto
git add archivo.txt
git commit -m "resolve: combinar cambios de main y feature"

Comandos avanzados con ramas

Rebase interactivo

# Rebase interactivo de últimos 3 commits
git rebase -i HEAD~3

# Opciones disponibles:
# pick = usar commit
# reword = cambiar mensaje
# edit = editar commit
# squash = combinar con anterior
# drop = eliminar commit

# Rebase rama completa sobre main
git rebase main feature-branch

Cherry-pick

# Aplicar commit específico a rama actual
git cherry-pick abc1234

# Cherry-pick múltiples commits
git cherry-pick abc1234 def5678

# Cherry-pick rango de commits
git cherry-pick abc1234..def5678

# Cherry-pick sin commit automático
git cherry-pick --no-commit abc1234

Stash para cambiar ramas rápidamente

# Guardar cambios temporalmente
git stash

# Cambiar de rama
git checkout otra-rama

# Volver y recuperar cambios
git checkout rama-original
git stash pop

# Ver lista de stashes
git stash list

# Aplicar stash específico
git stash apply stash@{1}

Mejores prácticas con ramas

Buenas prácticas

Nomenclatura de ramas

# Prefijos recomendados
feature/nombre-funcionalidad
bugfix/descripcion-error
hotfix/correccion-urgente
release/version-numero
experiment/prueba-concepto

# Ejemplos específicos
feature/login-social
feature/dashboard-admin
bugfix/validacion-email
hotfix/seguridad-sql-injection
release/v2.1.0

Estrategias de integración

Merge commits
Rebase

Cuándo usar:

Preservar contexto histórico
Funcionalidades grandes
Trabajo colaborativo

Ventajas:

Historial completo
Fácil revertir funcionalidad completa
Menos conflictos

Desventajas:

Historial más complejo
Más commits de merge

Protección de ramas

# En GitHub, configurar branch protection rules:
# - Require pull request reviews
# - Require status checks to pass
# - Require branches to be up to date
# - Require conversation resolution
# - Restrict pushes to matching branches

# Localmente, crear hooks para validación
# .git/hooks/pre-push
#!/bin/bash
if [ "$1" = "refs/heads/main" ]; then
  echo "Push directo a main no permitido"
  exit 1
fi

Resumen

En este módulo has aprendido:

Ramas en Git

✅ Concepto de ramas: Líneas independientes de desarrollo
✅ git branch: Crear, listar y eliminar ramas
✅ git checkout: Cambiar entre ramas
✅ git merge: Fusionar ramas y resolver conflictos
✅ Flujos de trabajo: Git Flow, GitHub Flow y flujos personalizados
✅ Comandos avanzados: Rebase, cherry-pick, stash
✅ Mejores prácticas: Nomenclatura, estrategias de integración
✅ Resolución de conflictos: Identificar, resolver y prevenir

En el próximo módulo aprenderemos sobre trabajo colaborativo, incluyendo forks, pull requests y las mejores prácticas para trabajar en equipo con Git y GitHub.

🐝