Commits, Ramas y Merges

En Git, los commits, las ramas y los merges son conceptos fundamentales que permiten gestionar el historial de cambios y facilitar el trabajo colaborativo. Entender cómo funcionan y cómo utilizarlos correctamente es esencial para cualquier desarrollador.

Commits: Guardando cambios en Git

Un commit es una instantánea de los cambios realizados en el repositorio en un momento específico. Cada commit tiene un identificador único (hash SHA-1) y contiene información sobre quién realizó los cambios, cuándo se hicieron y un mensaje descriptivo.

Anatomía de un commit

commit 8f937c683929b08379097828c8a04350b9b8e183
Author: Juan Pérez <juan@example.com>
Date:   Wed Apr 19 14:32:15 2025 -0500

    Implementa la funcionalidad de inicio de sesión
    
    - Añade formulario de login
    - Integra validación de credenciales
    - Configura redirección después del login exitoso

Un commit incluye:

• Hash: Identificador único (8f937c683929b...)
• Autor: Nombre y correo electrónico
• Fecha: Cuándo se realizó el commit
• Mensaje: Descripción de los cambios (título y cuerpo)

Creando commits

# Añadir archivos al área de preparación (staging)
git add archivo.txt
git add carpeta/
git add .  # Añadir todos los archivos modificados

# Crear un commit con los cambios preparados
git commit -m "Mensaje descriptivo del commit"

# Añadir y hacer commit en un solo paso (solo para archivos ya rastreados)
git commit -am "Mensaje descriptivo del commit"

Buenas prácticas para commits

1. Commits atómicos: Cada commit debe representar un cambio lógico único.
2. Mensajes descriptivos:
   • Primera línea: Resumen conciso (máximo 50 caracteres)
   • Líneas siguientes: Descripción detallada si es necesario
3. Convenciones de mensajes:

   feat: añade nueva funcionalidad
   fix: corrige un error
   docs: actualiza documentación
   style: cambios de formato (no afectan al código)
   refactor: refactoriza código existente
   test: añade o modifica pruebas
   chore: cambios en el proceso de construcción o herramientas
   

4. Verificar antes de confirmar:

   git diff --staged  # Ver cambios que se incluirán en el commit
   

Ramas (Branches): Desarrollo paralelo

Las ramas permiten desarrollar funcionalidades, experimentar o corregir errores de forma aislada sin afectar a la rama principal (generalmente main o master).

Conceptos básicos de ramas

• Rama principal: Tradicionalmente master o main, contiene el código estable.
• Rama de funcionalidad: Para desarrollar nuevas características.
• Rama de corrección: Para solucionar errores específicos.
• HEAD: Apuntador que indica la rama y commit actual en la que estás trabajando.

Trabajando con ramas

# Ver todas las ramas (la actual marcada con *)
git branch

# Crear una nueva rama
git branch nueva-funcionalidad

# Cambiar a una rama existente
git checkout nueva-funcionalidad

# Crear y cambiar a una nueva rama en un solo paso
git checkout -b nueva-funcionalidad

# Eliminar una rama (después de fusionarla)
git branch -d rama-completada

# Eliminar una rama (sin importar si se fusionó)
git branch -D rama-descartada

Estrategias de ramificación

1. Git Flow:
   • master: Código en producción
   • develop: Código en desarrollo
   • feature/*: Nuevas funcionalidades
   • release/*: Preparación para lanzamientos
   • hotfix/*: Correcciones urgentes
2. GitHub Flow:
   • main: Código principal, siempre desplegable
   • Ramas de funcionalidad: Para cada nueva característica o corrección
3. Trunk-Based Development:
   • Desarrollo principalmente en la rama principal
   • Ramas de corta duración para cambios específicos

Merges: Integrando cambios entre ramas

Un merge combina los cambios de una rama con otra, integrando el trabajo realizado en paralelo.

Tipos de merge

1. Fast-forward merge:
   • Ocurre cuando no hay commits adicionales en la rama destino desde que se creó la rama origen.
   • Git simplemente mueve el puntero de la rama destino.
2. Merge con commit de fusión:
   • Crea un nuevo commit que combina los cambios de ambas ramas.
   • Preserva el historial completo de ambas ramas.
3. Rebase:
   • No es un merge tradicional, pero logra un resultado similar.
   • Reaplica los commits de una rama sobre otra, creando un historial lineal.

Realizando merges

# Fusionar la rama "nueva-funcionalidad" en la rama actual
git merge nueva-funcionalidad

# Fusionar con mensaje personalizado
git merge nueva-funcionalidad -m "Integra la nueva funcionalidad de login"

# Fusionar sin fast-forward (siempre crear commit de merge)
git merge --no-ff nueva-funcionalidad

Resolviendo conflictos de merge

Cuando Git no puede fusionar automáticamente los cambios porque se modificaron las mismas líneas en ambas ramas, se produce un conflicto que debe resolverse manualmente:

1. Git marca los archivos con conflictos.
2. Edita los archivos para resolver los conflictos (elimina los marcadores y decide qué código mantener).
3. Añade los archivos resueltos al área de preparación.
4. Completa el merge con un commit.

# Después de un conflicto en el merge
git status  # Ver archivos con conflictos

# Resolver conflictos en el editor y luego
git add archivo-con-conflicto.txt
git commit  # Completar el merge

Ejemplo de un conflicto:

<<<<<<< HEAD
Esta es la versión de la rama actual
=======
Esta es la versión de la rama que estamos fusionando
>>>>>>> nueva-funcionalidad

Integrando los conceptos: Flujo de trabajo

Un flujo de trabajo típico en Git combinando commits, ramas y merges:

# 1. Actualizar la rama principal
git checkout main
git pull origin main

# 2. Crear una rama para una nueva funcionalidad
git checkout -b feature/login-system

# 3. Realizar cambios y hacer commits
git add login.html login.js
git commit -m "Añade formulario de login"

git add authentication.js
git commit -m "Implementa autenticación de usuarios"

# 4. Actualizar con cambios recientes de main (opcional)
git checkout main
git pull origin main
git checkout feature/login-system
git merge main  # O git rebase main

# 5. Enviar la rama al repositorio remoto
git push origin feature/login-system

# 6. Fusionar la funcionalidad en main (después de revisión)
git checkout main
git merge feature/login-system
git push origin main

# 7. Eliminar la rama de funcionalidad
git branch -d feature/login-system
git push origin --delete feature/login-system

Herramientas visuales

Para visualizar mejor commits, ramas y merges:

# Ver historial gráfico en la terminal
git log --graph --oneline --all --decorate

# Herramientas GUI populares
# - GitKraken
# - Sourcetree
# - GitHub Desktop
# - Visual Studio Code con extensión GitLens

Consejos avanzados

1. Commits interactivos:

   git add -p  # Añadir cambios selectivamente
   

2. Stashing: Guardar cambios temporalmente sin hacer commit

   git stash  # Guardar cambios
   git stash pop  # Recuperar cambios
   

3. Cherry-picking: Aplicar commits específicos a otra rama

   git cherry-pick abc123  # Aplicar el commit abc123 a la rama actual
   

4. Squash commits: Combinar varios commits en uno

   git rebase -i HEAD~3  # Modo interactivo para los últimos 3 commits
   

Conclusión

Los commits, ramas y merges son las herramientas fundamentales que hacen de Git un sistema de control de versiones poderoso. Dominar estos conceptos permite:

• Mantener un historial claro y organizado del proyecto
• Trabajar en paralelo en diferentes funcionalidades
• Colaborar eficientemente con otros desarrolladores
• Gestionar versiones y lanzamientos de forma controlada

Con práctica y siguiendo buenas prácticas, estos conceptos se convierten en parte natural del flujo de trabajo de desarrollo, mejorando significativamente la productividad y la calidad del código.