Aislamiento de trabajo

Una rama no es una copia de archivos: es un puntero móvil de 41 bytes

Crear una rama en Git no duplica tu código en disco. Una rama es simplemente un archivo de texto plano de 41 bytes en .git/refs/heads/ que guarda el hash de un commit. HEAD es un puntero simbólico que indica en qué rama estás parado.

Selecciona una rama para ver cómo se mueven los punteros internos de Git:
Archivo en disco: .git/HEAD ref: refs/heads/main Puntero de rama activa: .git/refs/heads/... 3a8f91c78490a1b2c3d4e5f6a7b8c9d0e1f2a3b4
C1
C2
C3
HEAD → main
Estrategias de unión

Fast-Forward vs 3-Way Merge: ¿cuándo se crea un merge commit?

Si la rama main no avanzó mientras trabajabas en feature, Git hace un Fast-Forward (solo desliza el puntero de main a la punta). Si main también avanzó, las historias divergieron y Git realiza un 3-Way Merge creando un commit de unión con dos padres.

Modo actual: Fast-Forward (historia lineal, sin commit extra).
Caso 1: Fast-Forward (main no avanzó)
main:
C1
C2 (base)
C3 (login)
C4 (login)
═════► main se desliza a C4

✓ Sin commits adicionales. El historial permanece perfectamente lineal y limpio.

Anatomía del conflicto

¿Por qué ocurre un conflicto? La máquina no puede adivinar

Git es capaz de fusionar automáticamente cambios si están en archivos diferentes o en líneas separadas. Pero si dos personas modificaron exactamente la misma línea del mismo archivo, Git no tiene criterio de negocio para saber cuál es la correcta.

1. Ancestro común (C2)
// config.ts
export const discount = 0.10;
export const currency = 'USD';

Valor original acordado la semana pasada.

2. Rama main (HEAD)
// config.ts
export const discount = 0.15;
export const currency = 'USD';

Marketing subió el descuento al 15% en main.

3. Rama feature
// config.ts
export const discount = 0.20;
export const currency = 'USD';

Tu tarea de Black Friday puso 20% en feature.

⚠️ ¿15% o 20%? Ningún algoritmo puede tomar esa decisión por ti. Git detiene el merge y te cede el control.

Resolución interactiva

Desarmando los marcadores de conflicto en tu editor

Cuando hay conflicto, Git edita tu archivo insertando 3 delimitadores: <<<<<<< HEAD (tu versión actual), ======= (separador divisorio) y >>>>>>> (versión entrante). Resuelve el conflicto eligiendo la opción correcta:

Opciones de resolución rápida:
src/config.ts ⚠️ CONFLICTO
// src/config.ts
<<<<<<< HEAD
export const discount = 0.15; // Versión en main
=======
export const discount = 0.20; // Versión en feature
>>>>>>> feature/login
export const currency = 'USD';

El archivo tiene marcadores activos. Haz clic en una de las 3 opciones para limpiarlo.

Terminal y comandos

git add para marcar resuelto, git commit para sellar

Una vez editado el archivo y eliminados todos los marcadores, debes notificarle a Git que la disputa terminó. El comando git add le indica que el archivo está resuelto en Staging, y git commit sella el merge commit final.

1
git status

Verifica los archivos en conflicto listados como "both modified".

2
Editar y validar

Abre el archivo, borra los marcadores, elige el código y corre los tests.

3
git add src/config.ts

Marca el conflicto como resuelto y traslada el archivo limpio al Staging Area.

4
git commit

Genera el commit de unión automático. En versiones modernas: git merge --continue.

🛟 El botón de escape de emergencia: git merge --abort

Si te equivocaste al resolver, el conflicto es inmanejable o necesitas consultar con un compañero antes de proceder, ejecuta git merge --abort. Git cancelará la fusión y devolverá todo tu repositorio al estado exacto antes de intentar el merge.

Buenas prácticas

Menos conflictos no es suerte: es disciplina arquitectónica

Los conflictos no se evitan rezando, sino diseñando el código y el flujo de trabajo para minimizar las zonas de colisión concurrente entre desarrolladores.

01

Ramas de vida corta (Short-lived branches)

Una rama que vive 2 días tiene muy pocas probabilidades de conflicto. Una rama que vive 3 semanas acumula cientos de diferencias imposibles de digerir.

02

Modularidad y archivos pequeños

Si 5 programadores editan un archivo gigante de 3000 líneas (God File), chocarán a diario. Divide en componentes y módulos cohesivos de responsabilidad única.

03

Sincronizar frecuentemente con main

Trae los cambios de main a tu rama varias veces al día. Resolver un conflicto de 2 líneas hoy es mil veces más fácil que resolver 40 archivos el viernes a la tarde.

04

Comunicación antes de refactors masivos

Si vas a cambiar el formateador (Prettier/ESLint) o renombrar carpetas clave, avísale al equipo y mergea en una ventana coordinada sin ramas abiertas.