Conflictos en Git: Qué son, por qué ocurren y cómo resolverlos paso a paso

Los conflictos en Git son una situación normal cuando dos o más personas modifican la misma parte de un archivo o cuando intentas combinar cambios de diferentes ramas. Aprender a resolverlos correctamente es una habilidad fundamental para cualquier desarrollador, ya que evita la pérdida de información y permite mantener un historial de cambios limpio y organizado.

En esta guía aprenderás qué son los conflictos en Git, cuándo aparecen, cómo solucionarlos paso a paso y cuáles son las mejores prácticas para prevenirlos.

1. ¿Qué es un conflicto en Git?

Un conflicto en Git ocurre cuando Git no puede decidir automáticamente qué cambios debe conservar al intentar unir dos versiones diferentes de un mismo archivo.

En otras palabras, Git detecta que existen modificaciones incompatibles y necesita que el desarrollador decida cuál será la versión final.

Generalmente aparecen durante operaciones como:

• git merge
• git pull
• git rebase
• Aplicación de algunos git stash

Git intenta resolver automáticamente la mayoría de los cambios. Sin embargo, cuando dos versiones modifican exactamente la misma línea o una zona muy cercana del archivo, necesita intervención manual.

2. ¿Por qué aparecen?

Los conflictos aparecen porque dos o más cambios distintos afectan el mismo contenido.

Por ejemplo:

• Dos desarrolladores modifican el mismo párrafo.
• Una rama elimina un archivo mientras otra lo modifica.
• Se renombra un archivo en una rama y se edita en otra.
• Se realizan cambios importantes durante mucho tiempo sin actualizar la rama.

Git no sabe cuál versión es la correcta y solicita que el desarrollador tome la decisión.

3. ¿Cuándo suelen aparecer?

Los conflictos pueden aparecer en distintas situaciones.

3.1. Durante un git merge

Es el caso más frecuente al unir ramas con git merge.

Dos ramas modificaron el mismo archivo y ahora intentas unirlas.

git merge desarrollo

Si existen cambios incompatibles, Git mostrará un mensaje similar a:

CONFLICT (content): Merge conflict in index.html
Automatic merge failed.Lenguaje del código: CSS (css)

3.2. Durante un git pull

Cuando descargas cambios del repositorio remoto, Git realiza internamente un merge.

Si tú modificaste el mismo archivo que otra persona, aparecerá el conflicto.

git pull origin main

3.3. Durante un git rebase

Al mover commits sobre otra rama también pueden aparecer conflictos.

git rebase main

En este caso Git irá deteniéndose en cada conflicto hasta que lo resuelvas.

3.4. Al aplicar un git stash

Si guardaste cambios temporalmente y luego intentas recuperarlos sobre un archivo que cambió, Git también puede generar conflictos.

git stash apply

4. ¿Cómo identificar un conflicto?

Cuando ocurre un conflicto, Git informa inmediatamente cuáles archivos tienen problemas.

Por ejemplo:

Auto-merging index.html
CONFLICT (content): Merge conflict in index.htmlLenguaje del código: CSS (css)

Además, si ejecutas:

git status

Obtendrás algo parecido a:

Unmerged paths

both modified: index.htmlLenguaje del código: CSS (css)

Esto indica que el archivo todavía necesita ser resuelto.

5. ¿Cómo se ve un conflicto dentro del archivo?

Supongamos que dos ramas modificaron el mismo <h1>.

Git mostrará algo similar a esto:

<<<<<<< HEAD
<h1>Curso completo de Git</h1>
=======
<h1>Aprende Git desde cero</h1>
>>>>>>> desarrollo

Estas marcas significan:

<<<<<<< HEAD

Representa los cambios de tu rama actual.

=======

Separa ambas versiones.

>>>>>>> desarrollo

Representa los cambios provenientes de la otra rama.

6. ¿Cómo resolver un conflicto en Git?

Resolver un conflicto consiste en decidir cuál será el contenido definitivo del archivo.

Los pasos son:

Paso 1. Abrir el archivo

Abre el archivo indicado por Git.

Por ejemplo:

index.htmlLenguaje del código: CSS (css)

Paso 2. Buscar las marcas del conflicto

Encontrarás algo parecido a:

<<<<<<< HEAD
...
=======
...
>>>>>>> desarrollo

Paso 3. Elegir el contenido correcto

Puedes:

• conservar la primera versión
• conservar la segunda
• combinar ambas
• escribir una versión completamente nueva

Por ejemplo:

<h1>Curso completo de Git desde cero</h1>Lenguaje del código: HTML, XML (xml)

Una vez hecho esto debes eliminar las marcas:

<<<<<<<
=======
>>>>>>>

Paso 4. Guardar el archivo

Después de editar el archivo, simplemente lo guardas.

Paso 5. Agregar nuevamente el archivo

git add index.htmlLenguaje del código: CSS (css)

Con esto le indicas a Git que el conflicto ya fue solucionado.

Paso 6. Finalizar el merge

Ahora solo queda crear el commit.

git commit

Git abrirá un mensaje automático indicando que el conflicto fue resuelto.

7. Ejemplo completo paso a paso

Supongamos este escenario.

Tenemos dos ramas.

main

y

desarrollo

En ambas existe el archivo:

<h1>Curso Git</h1>Lenguaje del código: HTML, XML (xml)

Paso 1

En la rama main modificamos:

<h1>Curso completo de Git</h1>Lenguaje del código: HTML, XML (xml)

Hacemos commit.

Paso 2

En la rama desarrollo modificamos la misma línea:

<h1>Aprende Git fácilmente</h1>Lenguaje del código: HTML, XML (xml)

También hacemos commit.

Paso 3

Ahora volvemos a la rama principal.

git switch mainLenguaje del código: JavaScript (javascript)

Paso 4

Intentamos unir ambas ramas.

git merge desarrollo

Git responde:

CONFLICT (content): Merge conflict in index.htmlLenguaje del código: CSS (css)

Paso 5

Abrimos el archivo.

Encontramos:

<<<<<<< HEAD
<h1>Curso completo de Git</h1>
=======
<h1>Aprende Git fácilmente</h1>
>>>>>>> desarrollo

Paso 6

Decidimos dejar una versión mejor.

<h1>Curso completo de Git para principiantes</h1>Lenguaje del código: HTML, XML (xml)

Guardamos.

Paso 7

Marcamos el archivo como resuelto.

git add index.htmlLenguaje del código: CSS (css)

Paso 8

Finalizamos.

git commit

El conflicto ya quedó resuelto.

8. Ejemplo en escenario real.

Imagina un equipo que desarrolla un sitio web.

Ana trabaja en la rama:

feature-menu

Modifica el menú principal agregando nuevos enlaces.

Mientras tanto, Carlos trabaja en:

feature-header

y cambia el mismo archivo para modificar el título y reorganizar el encabezado.

Ambos editan el archivo:

index.htmlLenguaje del código: CSS (css)

Cuando Ana termina, fusiona su rama con main.

Más tarde, Carlos intenta hacer:

git merge main

Git detecta que ambos modificaron parte del encabezado del mismo archivo y genera un conflicto.

Carlos abre el archivo, revisa ambos cambios y decide conservar:

• el nuevo menú creado por Ana;
• el nuevo encabezado que él desarrolló.

Después elimina las marcas del conflicto, guarda el archivo, ejecuta:

git add index.htmlLenguaje del código: CSS (css)

y finalmente:

git commit

De esta manera, el proyecto conserva los cambios de ambos desarrolladores sin perder información.

9. ¿Cómo evitar conflictos en Git?

Aunque no siempre pueden evitarse, existen buenas prácticas que reducen mucho su aparición.

9.1. Actualiza tu rama con frecuencia

Antes de comenzar a trabajar ejecuta:

git pull origin main

Así trabajas sobre la versión más reciente del proyecto.

9.2. Realiza commits pequeños

Los cambios pequeños son mucho más fáciles de combinar.

9.3. No trabajes muchos días sin sincronizar

Cuanto más tiempo permanezca una rama aislada, mayor será la probabilidad de conflictos.

9.4. Divide el trabajo del equipo

Si cada desarrollador trabaja en archivos diferentes, será menos probable modificar las mismas líneas.

9.5. Comunícate con el equipo

Cuando varias personas necesitan editar el mismo archivo, es recomendable coordinar previamente quién realizará cada cambio.

10. Herramientas visuales para resolver conflictos

Aunque los conflictos pueden resolverse desde la terminal, la mayoría de los editores modernos ofrecen herramientas gráficas que simplifican el proceso.

Visual Studio Code

Cuando abres un archivo con conflictos, VS Code muestra opciones como:

• Accept Current Change
• Accept Incoming Change
• Accept Both Changes
• Compare Changes

Esto permite resolver conflictos con unos pocos clics sin editar manualmente las marcas del archivo.

GitHub Desktop

También permite resolver conflictos sencillos mediante una interfaz gráfica antes de realizar el commit.

Otras herramientas

Git puede integrarse con aplicaciones especializadas para comparar archivos y resolver conflictos de forma visual, especialmente útiles en proyectos grandes.

11. Errores comunes al resolver conflictos

Estos son algunos errores frecuentes que conviene evitar:

• Eliminar accidentalmente código importante al borrar las marcas del conflicto.
• Olvidar ejecutar git add después de resolver el archivo.
• Hacer git commit sin revisar que el resultado final sea correcto.
• Resolver el conflicto sin probar la aplicación.
• Aceptar una versión completa sin verificar si la otra contiene cambios necesarios.

12. Resumen

Los conflictos en Git son una parte habitual del trabajo colaborativo y no indican que algo haya salido mal. Simplemente significan que Git necesita ayuda para decidir cómo combinar cambios incompatibles. Saber identificar las marcas de conflicto, editar el archivo correctamente, marcarlo como resuelto con git add y finalizar la operación con un commit te permitirá trabajar con seguridad tanto en proyectos personales como en equipos de desarrollo. Dominar esta habilidad es esencial para aprovechar todo el potencial del control de versiones con Git.