🔀 Resolución de Conflictos en Git

Has estado trabajando tranquilo en tu rama, haciendo commits, cuando de repente intentas hacer un git merge o git pull y aparece algo así:

Auto-merging archivo.js
CONFLICT (content): Merge conflict in archivo.js
Automatic merge failed; fix conflicts and then commit the result.

¡Felicidades! Has encontrado tu primer conflicto de merge. No te preocupes, en esta lección aprenderás exactamente qué son, por qué ocurren y cómo resolverlos como un profesional.

¿Por Qué Ocurren los Conflictos?

Los conflictos son una consecuencia natural del trabajo colaborativo. Ocurren porque:

• Múltiples desarrolladores modifican el mismo archivo simultáneamente
• Alguien edita una función que tú también estás editando
• Se borran archivos en una rama y se modifican en otra
• Los cambios en diferentes ramas afectan las mismas líneas de código

Identificando un Conflicto

Cuando intentas hacer un merge y hay conflictos, Git te lo indica claramente:

1. El comando git merge o git pull se detiene
2. Aparece el mensaje "CONFLICT" junto al archivo afectado
3. El archivo conflictivo tendrá marcadores especiales en su contenido
4. Puedes verificar todos los archivos en conflicto con git status

Los Marcadores de Conflicto

Cuando abres un archivo con conflicto, verás algo como esto:

<<<<<<< HEAD
const nombre = "María";
=======
const nombre = "Carlos";
>>>>>>> rama-login

function saludar() {
  console.log("Hola " + nombre);
}

Desglosemos estas secciones:

Resolviendo Conflictos Paso a Paso

Ahora viene la parte práctica. Aquí está el proceso completo para resolver conflictos:

Paso 1: Identificar Todos los Archivos en Conflicto

git status
# Verás algo como:
# Unmerged paths:
#   both modified:   src/app.js
#   both modified:   src/utils.js

Paso 2: Abrir los Archivos Afectados

Abre cada archivo en tu editor de código favorito. Verás los marcadores de conflicto que mostramos antes.

Paso 3: Decidir la Estrategia de Resolución

Tienes cuatro opciones para cada conflicto:

1. Mantener solo tu versión (HEAD): Borra todo incluyendo los marcadores y los cambios de la otra rama
2. Mantener solo la otra versión: Borra todo incluyendo los marcadores y tus cambios
3. Combinar ambas versiones: Integra los cambios de ambas ramas de forma manual
4. Escribir algo completamente nuevo: A veces la mejor solución es un código diferente a ambas versiones

Paso 4: Editar el Archivo

Elimina los marcadores de conflicto y deja únicamente el código que deseas:

# ANTES (con marcadores):
<<<<<<< HEAD
const nombre = "María";
=======
const nombre = "Carlos";
>>>>>>> rama-login

# DESPUÉS (resuelto):
const nombre = "María García";  // Combinamos: nombre + apellido

# O si decides usar la otra versión:
const nombre = "Carlos";

# O si combinas ambas:
const nombre = "María";
const segundoNombre = "Carlos";

Paso 5: Guardar y Marcar como Resuelto

Después de editar cada archivo:

git add src/app.js

# Si tienes varios archivos:
git add .

Paso 6: Completar el Merge

git commit -m "Merge rama-login: resuelvo conflictos en app.js"

# Si Git abrió el editor automáticamente, simplemente guarda y cierra

Usando Visual Studio Code para Resolver Conflictos

VS Code tiene herramientas integradas que hacen la resolución de conflictos mucho más fácil:

Funciones Útiles de VS Code:

• Resolución con un clic: El editor resalta en colores las diferencias y ofrece botones para aceptar cambios
• Vista lado a lado: Puedes ver ambas versiones simultáneamente
• Resaltado de sintaxis: El código dentro de los marcadores mantiene los colores
• GitLens y extensiones: Herramientas adicionales para gestión visual de conflictos

# En VS Code puedes:
# 1. Hacer clic en "Accept Current Change"  → Usa tu versión
# 2. Hacer clic en "Accept Incoming Change"  → Usa la otra versión  
# 3. Hacer clic en "Accept Both Changes"     → Mantiene las dos
# 4. Editar manualmente el código

Estrategias para Evitar Conflictos

Conflictos Durante un Rebase

Los conflictos también pueden ocurrir durante un git rebase. El proceso es similar, pero con una diferencia clave:

# Durante un rebase con conflicto:
# 1. Resuelve el conflicto en el archivo

git add archivo-resuelto.js

# 2. Continúa con el siguiente commit
git rebase --continue

# Si quieres abortar todo el rebase:
git rebase --abort

# Si quieres saltarte este commit problemático:
git rebase --skip

Abortar un Merge Conflictivo

A veces simplemente quieres empezar de nuevo. Git te permite revertir un merge:

# Abortar el merge en curso
git merge --abort

# Esto revertirá todo al estado antes del merge
git status  # Verás que estás de vuelta en tu rama original

Un buen desarrollador sabe cuándo resolver un conflicto y cuándo retroceder y replanificar. Abortar no es rendirse, es tomar una decisión inteligente.

Herramientas Avanzadas para Conflictos

git config --global merge.tool nombre-herramienta
git mergetool

Buenas Prácticas Post-Conflicto

1. Prueba siempre el código: Ejecuta los tests después de resolver conflictos
2. Revisa el código completo: Asegúrate de que la lógica tenga sentido
3. Comunica a tu equipo: Si el conflicto involucraba código de otros, notifícales
4. Documenta decisiones: En el mensaje de commit explica por qué elegiste cierta versión
5. Haz push: Sube los cambios resueltos lo antes posible

# Ejemplo de buen mensaje de commit post-conflicto:
git commit -m "Merge feature/pagos: resuelvo conflicto en calculo.js

- Mantengo mi validación de email del frontend
- Agrego la función de sanitización de backend
- Resuelto conflicto con María sobre formato de fechas

Verifico: todos los tests pasan ✓"

Resumen Rápido

Conclusión

Los conflictos de merge pueden parecer intimidantes al principio, pero con práctica se convierten en algo rutinario. Recuerda: cada conflicto es simplemente Git pidiéndote que tomes una decisión informada sobre el código. Con las técnicas de esta lección, podrás resolver cualquier conflicto de manera eficiente y mantener tu código funcionando correctamente.

En la próxima lección, exploraremos las estrategias de branching para equipos y cómo organizar el flujo de trabajo para minimizar conflictos desde el diseño inicial del proyecto.