Explorar guías rápidas · Git

Tecnología: GitCategoría: Control de versionesNivel: IntermedioActualizado

Resolver conflictos de merge

Resuelve conflictos de merge en Git de forma segura identificando la operación en curso, entendiendo ours y theirs, revisando el resultado combinado que buscas y completando o abortando el merge sin perder trabajo.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Identifica qué operación de Git está en curso
  5. 2. Lista solo los archivos sin resolver
  6. 3. Inspecciona los fragmentos sin resolver
  7. 4. Entiende los marcadores de conflicto
  8. 5. No conserves los marcadores de conflicto
  9. 6. Entiende ours y theirs durante un merge normal
  10. 7. Ten cuidado con ours y theirs durante un rebase
  11. 8. Acepta el lado actual para un archivo durante un merge
  12. 9. Acepta el lado entrante para un archivo durante un merge
  13. 10. Inspecciona directamente las versiones de cada etapa
  14. 11. Muestra la versión del ancestro común
  15. 12. Muestra la versión ours
  16. 13. Muestra la versión theirs
  17. 14. Resuelve manualmente cuando ambos lados contienen cambios válidos
  18. 15. Añade un archivo resuelto al área de preparación
  19. 16. Confirma qué archivos siguen sin resolver
  20. 17. Revisa la resolución preparada
  21. 18. Completa un merge normal
  22. 19. Aborta un merge normal
  23. 20. Continúa un rebase después de resolver
  24. 21. Aborta un rebase
  25. 22. No uses git rebase --skip solo para evitar un conflicto
  26. 23. Continúa un cherry-pick después de conflictos
  27. 24. Aborta un cherry-pick
  28. 25. Continúa un revert después de conflictos
  29. 26. Aborta un revert
  30. 27. Gestiona los conflictos de un stash apply
  31. 28. Conserva el stash hasta verificar la restauración
  32. 29. Usa git stash branch para un stash antiguo con muchos conflictos
  33. 30. Resuelve deliberadamente los conflictos de eliminación/modificación
  34. 31. Resuelve los conflictos de adición/adición
  35. 32. Resuelve con cuidado los conflictos de renombrado
  36. 33. Compara los cambios de las ramas antes de reintentar un merge difícil
  37. 34. Crea una rama de seguridad antes de un trabajo complejo con conflictos
  38. 35. Usa mergetool solo cuando aporte claridad
  39. 36. Configura explícitamente una herramienta de merge
  40. 37. Usa el editor de merge de VS Code cuando sea apropiado
  41. 38. Busca marcadores de conflicto antes de hacer commit
  42. 39. Aplica el formateo solo después de la resolución semántica
  43. 40. Ejecuta las pruebas después de resolver
  44. 41. Inspecciona el resultado preparado exacto antes de completar
  45. 42. No incluyas limpiezas no relacionadas en la resolución de conflictos
  46. 43. Resuelve los archivos generados desde su origen cuando sea posible
  47. 44. Gestiona los conflictos de archivos de bloqueo con el gestor de paquetes cuando sea posible
  48. 45. No resuelvas conflictos binarios combinando texto
  49. 46. Vigila los conflictos semánticos que Git no informa
  50. 47. Vigila la lógica duplicada después de merges limpios
  51. 48. Usa git log --merge durante un merge con conflictos
  52. 49. Inspecciona el historial de un archivo en conflicto
  53. 50. Usa blame para obtener contexto histórico, no para buscar culpables
  54. 51. Entiende los conflictos repetidos durante un rebase
  55. 52. Activa rerere solo si lo entiendes
  56. 53. Muestra el estado de rerere
  57. 54. Prefiere ramas más pequeñas y de vida más corta
  58. 55. Integra por separado las refactorizaciones estructurales cuando sea posible
  59. 56. No aproveches la resolución de conflictos para «limpiarlo todo»
  60. 57. Verifica la dirección de integración de las ramas después de resolver
  61. 58. Verifica el diff de la funcionalidad después de un rebase
  62. 59. Usa reflog si la resolución de conflictos o el trabajo con el historial sale mal
  63. 60. Crea un flujo repetible para resolver conflictos
  64. Qué significa el resultado
  65. Qué revisar
  66. El conflicto aparece en un archivo que ambas ramas cambiaron mucho
  67. El mismo conflicto aparece repetidamente durante un rebase
  68. ours / theirs parece al revés
  69. El merge se completa, pero las pruebas fallan
  70. Aparece de forma inesperada una enorme cantidad de conflictos
  71. El conflicto está solo en salida generada
  72. Notas de producción
  73. Un conflicto es una decisión de integración
  74. La resolución de conflictos debe poder revisarse
  75. El historial de una rama compartida no debe reescribirse solo para evitar resolver conflictos
  76. Las pruebas forman parte de la resolución de conflictos
  77. La resolución asistida por herramientas sigue requiriendo criterio
  78. La frecuencia de los conflictos es una señal sobre el flujo de trabajo
  79. Errores comunes
  80. 1. Elegir ours/theirs sin comprobar la operación
  81. 2. Hacer clic en «Accept Both» de forma automática
  82. 3. Añadir un archivo al área de preparación antes de verificar la resolución
  83. 4. Ejecutar reset --hard cuando aparece un conflicto
  84. 5. Usar rebase --skip para evitar conflictos difíciles
  85. 6. Dejar marcadores de conflicto en el código fuente
  86. 7. Resolver archivos generados manualmente sin revisar el flujo de generación
  87. 8. Tratar un merge limpio de Git como una combinación correcta de la aplicación
  88. 9. Mezclar refactorizaciones no relacionadas con la resolución
  89. 10. Continuar antes de haber resuelto todas las rutas pendientes
  90. Siguiente paso
  91. Para profundizar

Problema

Git se detuvo durante un merge, un rebase, un cherry-pick, un stash apply o un revert porque no pudo combinar automáticamente dos cambios.

Lo difícil no es eliminar los marcadores de conflicto.

El problema real es decidir cómo debe quedar el código final sin:

  • perder cambios válidos de cualquiera de los dos lados
  • elegir ours o theirs a ciegas
  • resolver contra la rama equivocada
  • hacer commit con marcadores de conflicto
  • ocultar conflictos semánticos que Git no puede detectar
  • completar la operación de Git equivocada
  • descartar trabajo al intentar recuperarte

El objetivo es identificar la operación, entender ambos lados, resolver según el comportamiento previsto, validar el resultado y luego continuar o abortar de forma segura.

Respuesta rápida

Empieza con:

git status

Lista los archivos sin resolver:

git diff --name-only --diff-filter=U

Inspecciona los conflictos:

git diff

Un conflicto suele tener este aspecto:

<<<<<<< HEAD
current-side content
=======
incoming-side content
>>>>>>> branch-or-commit

Resuelve el archivo manualmente, elimina los marcadores y añádelo al área de preparación:

git add path/to/file

Completa la operación:

Merge
→ git commit

Rebase
→ git rebase --continue

Cherry-pick
→ git cherry-pick --continue

Revert
→ git revert --continue

Si la operación es incorrecta o no es segura:

Merge
→ git merge --abort

Rebase
→ git rebase --abort

Cherry-pick
→ git cherry-pick --abort

Revert
→ git revert --abort

No ejecutes git reset --hard solo porque haya aparecido un conflicto.

Código / comandos

1. Identifica qué operación de Git está en curso

Ejecuta:

git status

Git te dirá si estás en:

  • un merge
  • un rebase
  • un cherry-pick
  • un revert
  • un estado normal del árbol de trabajo

El comando correcto para continuar o abortar depende de la operación.


2. Lista solo los archivos sin resolver

git diff --name-only --diff-filter=U

Esto te da los archivos que Git todavía considera sin fusionar (unmerged).

Úsalo cuando un conflicto abarca muchos archivos.


3. Inspecciona los fragmentos sin resolver

git diff

Durante una operación de tipo merge sin resolver, esto muestra las zonas en conflicto y los cambios que las rodean.

Revisa el código, no solo los nombres de archivo.


4. Entiende los marcadores de conflicto

Conflicto típico:

<<<<<<< HEAD
return old_behavior();
=======
return new_behavior();
>>>>>>> feature/new-behavior

Las secciones significan:

<<<<<<< HEAD
contenido de un lado

=======
separador

>>>>>>> ...
contenido del otro lado

Tu trabajo es reemplazar todo el bloque en conflicto por el código final correcto.


5. No conserves los marcadores de conflicto

Archivo final incorrecto:

<<<<<<< HEAD
...
=======
...
>>>>>>> feature

Git puede permitir añadirlo al área de preparación si los marcadores se editaron de forma inusual, pero la aplicación contendrá contenido no válido o no deseado.

Busca antes de hacer commit:

git grep -n '<<<<<<<\|=======\|>>>>>>>'

Revisa cada coincidencia, porque algunos repositorios pueden contener cadenas similares de forma intencionada en pruebas o documentación.


6. Entiende ours y theirs durante un merge normal

Si estás en:

main

y ejecutas:

git merge feature/report-engine

entonces, durante ese merge:

ours
→ main / rama actual

theirs
→ feature/report-engine / rama entrante

Este es el caso intuitivo.


7. Ten cuidado con ours y theirs durante un rebase

Durante un rebase, las etiquetas pueden parecer invertidas respecto al modelo mental del desarrollador, porque Git está reaplicando commits sobre la nueva base.

No decidas basándote solo en las palabras.

Usa:

git status
git diff

e inspecciona el contenido real.

Resuelve según el código final que buscas.


8. Acepta el lado actual para un archivo durante un merge

git restore --ours path/to/file

Después, añádelo al área de preparación:

git add path/to/file

Úsalo solo cuando todo el archivo deba venir del lado actual.


9. Acepta el lado entrante para un archivo durante un merge

git restore --theirs path/to/file

Después:

git add path/to/file

Úsalo solo cuando todo el archivo deba venir del lado entrante.

La mayoría de los conflictos reales necesitan, en cambio, una resolución manual combinada.


10. Inspecciona directamente las versiones de cada etapa

Durante un conflicto sin fusionar, el índice de Git (el área de preparación o staging area) puede contener varias etapas (stages).

Inspecciónalas con:

git ls-files -u

Etapas habituales:

1 = ancestro común
2 = ours
3 = theirs

Esto es útil para una depuración avanzada cuando los marcadores de conflicto no están claros.


11. Muestra la versión del ancestro común

git show :1:path/to/file

Úsalo cuando necesites entender desde qué punto cambiaron ambos lados.


12. Muestra la versión ours

git show :2:path/to/file

13. Muestra la versión theirs

git show :3:path/to/file

Estas referencias de etapa son especialmente útiles para el análisis manual de conflictos complejos.


14. Resuelve manualmente cuando ambos lados contienen cambios válidos

Ejemplo de conflicto:

<<<<<<< HEAD
timeout = 30
retries = 2
=======
timeout = 60
backoff_seconds = 5
>>>>>>> feature/retry-policy

Posible resultado combinado correcto:

timeout = 60
retries = 2
backoff_seconds = 5

La respuesta correcta depende de la intención de la aplicación.

Un conflicto es una decisión de diseño del código, no un ejercicio de selección de texto.


15. Añade un archivo resuelto al área de preparación

git add path/to/file

Añadirlo al área de preparación le dice a Git:

Considero resuelto este conflicto.

No demuestra que la resolución sea correcta.


16. Confirma qué archivos siguen sin resolver

git status

o:

git diff --name-only --diff-filter=U

No continúes hasta que la lista de archivos sin resolver esté vacía.


17. Revisa la resolución preparada

Después de añadir los archivos al área de preparación:

git diff --cached

Esto es fundamental.

Muestra lo que se registrará cuando continúe el merge, el rebase, el cherry-pick o el revert.


18. Completa un merge normal

Cuando todos los conflictos estén en el área de preparación:

git commit

Git normalmente prepara un mensaje de commit de merge.

Revísalo antes de guardarlo.


19. Aborta un merge normal

git merge --abort

Úsalo cuando:

  • hiciste merge de la rama equivocada
  • el alcance del conflicto es inesperadamente grande
  • el enfoque de integración no es seguro
  • necesitas volver al estado anterior al merge

20. Continúa un rebase después de resolver

git add path/to/file
git rebase --continue

Repite para cada commit reaplicado que entre en conflicto.


21. Aborta un rebase

git rebase --abort

Esto devuelve la rama a su estado anterior al rebase.

Úsalo cuando la base elegida o la estrategia de rebase eran incorrectas.


22. No uses git rebase --skip solo para evitar un conflicto

git rebase --skip

descarta el commit que se está reaplicando en ese momento.

Úsalo solo cuando ese commit sea realmente innecesario o ya esté representado en otro lugar.


23. Continúa un cherry-pick después de conflictos

git add path/to/file
git cherry-pick --continue

24. Aborta un cherry-pick

git cherry-pick --abort

Úsalo si el commit seleccionado no debe aplicarse.


25. Continúa un revert después de conflictos

git add path/to/file
git revert --continue

26. Aborta un revert

git revert --abort

Úsalo cuando revertir el commit no sea seguro o se haya seleccionado el commit equivocado.


27. Gestiona los conflictos de un stash apply

Si:

git stash apply stash@{0}

genera conflictos, usa:

git status
git diff

Resuelve los archivos y añádelos al área de preparación como de costumbre.

El siguiente comando:

git stash --continue

no existe.


28. Conserva el stash hasta verificar la restauración

Cuando hay trabajo importante en juego:

git stash apply stash@{0}

es más seguro que:

git stash pop

porque el stash sigue disponible mientras resuelves y verificas el árbol de trabajo.


29. Usa git stash branch para un stash antiguo con muchos conflictos

git stash branch recovered-wip stash@{0}

Esto crea una rama a partir del commit en el que se creó originalmente el stash, aplica el stash allí y lo elimina si la aplicación tiene éxito.

Puede reducir los conflictos cuando la rama actual se ha alejado mucho.


30. Resuelve deliberadamente los conflictos de eliminación/modificación

Ejemplo:

una rama eliminó config.py
la otra rama modificó config.py

Pregúntate:

¿El archivo debe seguir existiendo?

Si la respuesta es sí, restáuralo o resuélvelo y añádelo al área de preparación.

Si es no, elimínalo y añade la eliminación al área de preparación:

git rm config.py

No conserves ni elimines el archivo automáticamente sin entender por qué uno de los lados lo eliminó.


31. Resuelve los conflictos de adición/adición

Si ambas ramas crearon la misma ruta con contenido distinto, Git no puede saber si representan:

  • dos implementaciones de lo mismo
  • dos archivos que deben combinarse
  • una implementación obsoleta

Abre ambas versiones y diseña el archivo final que buscas.


32. Resuelve con cuidado los conflictos de renombrado

Los conflictos relacionados con renombrados pueden implicar:

  • renombrado/renombrado
  • renombrado/eliminación
  • renombrado/modificación

Comprueba:

git status

e inspecciona las rutas implicadas.

No te fíes solo de la similitud de los nombres de archivo; verifica la identidad del archivo y su destino previsto.


33. Compara los cambios de las ramas antes de reintentar un merge difícil

Después de abortar:

git diff origin/main...feature/report-engine

y:

git log \
  --oneline \
  --graph \
  --decorate \
  origin/main \
  feature/report-engine

Úsalo para entender la divergencia antes de volver a intentar la integración.


34. Crea una rama de seguridad antes de un trabajo complejo con conflictos

git branch backup-before-conflict-resolution

Esto es útil antes de:

  • un rebase complicado
  • una cirugía manual de ramas
  • una limpieza de conflictos arriesgada

Una referencia de rama es un seguro barato.


35. Usa mergetool solo cuando aporte claridad

Si está configurado:

git mergetool

Una herramienta de merge de tres vías puede mostrar:

base
ours
theirs
resultado

Puede resultar más sencillo que los marcadores en bruto en archivos grandes.

La herramienta no decide por ti si la aplicación es correcta.


36. Configura explícitamente una herramienta de merge

Patrón de ejemplo:

git config --global merge.tool <tool-name>

La configuración exacta de la herramienta depende del editor o la herramienta de merge instalados.

No copies a ciegas un comando de herramienta sin confirmar que existe en tu entorno.


37. Usa el editor de merge de VS Code cuando sea apropiado

Si VS Code es tu editor configurado, los archivos en conflicto pueden abrirse en su editor de merge.

Se aplica la misma regla:

Current / Incoming / Both

son ayudas de edición.

No sustituyen la comprensión del comportamiento final deseado.


38. Busca marcadores de conflicto antes de hacer commit

git grep -n '<<<<<<<\|=======\|>>>>>>>'

Inspecciona también el parche preparado:

git diff --cached

Así detectas marcadores que se hayan quedado por accidente.


39. Aplica el formateo solo después de la resolución semántica

No dejes que el formateo automático oculte el conflicto real mientras decides entre los cambios.

Orden más seguro:

resolver el comportamiento
→ preparar/revisar
→ formatear si es necesario
→ revisar el diff final
→ probar

40. Ejecuta las pruebas después de resolver

Como mínimo, ejecuta las comprobaciones pertinentes para el proyecto:

pruebas unitarias
pruebas de integración
lint
comprobación de tipos
build

Git puede resolver texto.

No puede determinar si el comportamiento combinado de la aplicación es correcto.


41. Inspecciona el resultado preparado exacto antes de completar

git diff --cached

Para un commit de merge, inspecciona también:

git status

Asegúrate de que solo estén preparados los archivos previstos.


42. No incluyas limpiezas no relacionadas en la resolución de conflictos

Evita hacer al mismo tiempo:

  • renombrar archivos no relacionados
  • formatear módulos completos
  • refactorizar el código cercano
  • cambiar dependencias

Mantén la resolución de conflictos acotada para que el diff de integración se pueda revisar.


43. Resuelve los archivos generados desde su origen cuando sea posible

Si un archivo generado entra en conflicto:

package-lock
salida compilada
esquema generado
artefacto de generación de código

primero entiende el proceso de generación de referencia del proyecto.

A menudo el enfoque correcto es:

resolver el origen/la entrada
→ regenerar el artefacto

en lugar de combinar manualmente la salida generada.

No apliques esto a ciegas a archivos cuyo estado generado se versiona intencionadamente con reglas especiales.


44. Gestiona los conflictos de archivos de bloqueo con el gestor de paquetes cuando sea posible

En los archivos de bloqueo de dependencias, editar manualmente los marcadores de conflicto puede producir fácilmente un estado no válido.

Una estrategia habitual es:

resolver el manifiesto de dependencias
→ regenerar el archivo de bloqueo con el gestor de paquetes/la versión correctos
→ inspeccionar el diff resultante

Sigue el flujo de dependencias documentado en el repositorio.


45. No resuelvas conflictos binarios combinando texto

En los archivos binarios, Git no puede combinar el contenido de forma significativa.

Elige la versión prevista o regenera el artefacto.

Después, añade el archivo resuelto al área de preparación.


46. Vigila los conflictos semánticos que Git no informa

Ejemplo:

Rama A:

calculate_total(items)

La rama B cambia la firma de la función:

def calculate_total(items, currency):
    ...

Si los cambios se producen en archivos distintos, Git puede combinarlos sin conflicto aunque el código quede roto.

Después de la integración, ejecuta las pruebas, el build y las comprobaciones de tipos.


47. Vigila la lógica duplicada después de merges limpios

Dos ramas pueden añadir de forma independiente:

gestión de reintentos
validación
feature flags
configuración

Git puede combinar ambas automáticamente aunque el comportamiento resultante sea redundante o contradictorio.

Revisa el diff a nivel de funcionalidad, no solo los archivos con conflictos textuales.


48. Usa git log --merge durante un merge con conflictos

Durante un merge sin resolver:

git log --merge --oneline

Esto puede ayudarte a ver los commits de ambos lados que tocan las rutas en conflicto.

Úsalo para obtener contexto histórico.


49. Inspecciona el historial de un archivo en conflicto

git log \
  --oneline \
  -- path/to/file

Para ver los parches:

git log \
  -p \
  -- path/to/file

Útil cuando necesitas entender por qué cada lado cambió el mismo código.


50. Usa blame para obtener contexto histórico, no para buscar culpables

git blame path/to/file

Úsalo para encontrar los commits relevantes.

Después, inspecciona esos commits:

git show <commit>

51. Entiende los conflictos repetidos durante un rebase

Un rebase reaplica los commits uno a uno.

Si varios commits modifican la misma zona, pueden aparecer conflictos similares varias veces.

Entre las opciones están:

  • resolver fielmente cada reaplicación
  • abortar y reorganizar los commits privados
  • usar merge en su lugar si reaplicar el historial añade demasiado riesgo

52. Activa rerere solo si lo entiendes

git config rerere.enabled true

rerere puede recordar resoluciones de conflictos anteriores y reutilizarlas cuando vuelve a aparecer el mismo conflicto.

Revisa las resoluciones reutilizadas.

No des por hecho que lo recordado sigue siendo correcto.


53. Muestra el estado de rerere

Cuando rerere está activado:

git rerere status

Esto ayuda a identificar los archivos para los que Git está registrando o reutilizando resoluciones de conflictos.


54. Prefiere ramas más pequeñas y de vida más corta

Los conflictos grandes y frecuentes suelen indicar:

  • ramas de funcionalidad de larga duración
  • refactorizaciones amplias
  • responsabilidades que se solapan
  • integración poco frecuente

Reducir la divergencia puede evitar conflictos, en lugar de hacer cada vez más sofisticadas las herramientas de resolución.


55. Integra por separado las refactorizaciones estructurales cuando sea posible

Si una rama:

renombra 100 archivos

mientras otra:

cambia la lógica de negocio de esos archivos

los conflictos se vuelven más difíciles de analizar.

Separa las refactorizaciones mecánicas de los cambios de comportamiento cuando sea viable.


56. No aproveches la resolución de conflictos para «limpiarlo todo»

El objetivo es preservar el comportamiento previsto de ambas líneas de desarrollo.

Los cambios grandes y no relacionados hacen que:

  • la revisión sea más difícil
  • la reversión sea más difícil
  • el análisis de los conflictos sea más difícil

Mantén la resolución al mínimo.


57. Verifica la dirección de integración de las ramas después de resolver

Para un merge:

git log \
  --oneline \
  --graph \
  --decorate \
  -15

Confirma que se integraron las ramas esperadas.


58. Verifica el diff de la funcionalidad después de un rebase

git diff origin/main...HEAD

Asegúrate de que la resolución de conflictos no eliminó por accidente cambios necesarios de la funcionalidad.


59. Usa reflog si la resolución de conflictos o el trabajo con el historial sale mal

git reflog

Encuentra la punta anterior de la rama.

Después:

git switch -c conflict-recovery <old-commit>

Hazlo antes de realizar más cambios destructivos en el historial.


60. Crea un flujo repetible para resolver conflictos

Usa:

1. git status
2. identificar la operación
3. listar los archivos sin resolver
4. inspeccionar cada conflicto
5. entender base/ours/theirs
6. resolver el comportamiento previsto
7. git add de los archivos resueltos
8. git diff --cached
9. buscar marcadores de conflicto
10. ejecutar pruebas/build
11. continuar o hacer commit
12. inspeccionar el historial final

Es más seguro que hacer clic en «Accept Both» una y otra vez esperando que el resultado funcione.

Qué significa el resultado

Estado/comando Significado
git status Muestra la operación y las rutas sin resolver
git diff --name-only --diff-filter=U Lista los archivos sin fusionar
git diff Muestra el contenido de los conflictos sin resolver
git restore --ours Toma la versión del archivo del lado actual en el estado de merge aplicable
git restore --theirs Toma la versión del archivo del lado entrante en el estado de merge aplicable
git add Marca el contenido resuelto en el índice
git merge --abort Aborta el merge actual
git rebase --continue Continúa la reaplicación después de resolver
git rebase --abort Restaura el estado anterior al rebase
git cherry-pick --continue Continúa el cherry-pick
git revert --continue Continúa el revert
git ls-files -u Muestra las etapas sin fusionar del índice
git show :1:file Ancestro común
git show :2:file Ours
git show :3:file Theirs

La distinción más importante es:

resolución textual del conflicto
!=
corrección de la aplicación

Qué revisar

El conflicto aparece en un archivo que ambas ramas cambiaron mucho

Inspecciona el historial y el ancestro común antes de resolver.

La respuesta correcta puede requerir combinar intenciones, no elegir un lado.

El mismo conflicto aparece repetidamente durante un rebase

Se están reaplicando varios commits sobre la misma zona modificada.

Valora si un merge o una limpieza del historial privado sería más seguro.

ours / theirs parece al revés

Puede que estés en un rebase o en otra operación de reaplicación.

Inspecciona el contenido real en lugar de fiarte de las etiquetas.

El merge se completa, pero las pruebas fallan

Busca conflictos semánticos que Git no pudo detectar.

Revisa los cambios en archivos e interfaces cercanos.

Aparece de forma inesperada una enorme cantidad de conflictos

Detente y comprueba:

  • la rama actual
  • la rama entrante
  • la base del merge (merge base)
  • si la rama se creó a partir de la base esperada

Abortar puede ser más seguro que resolver una integración equivocada.

El conflicto está solo en salida generada

Resuelve el origen de referencia y regenera cuando el flujo del repositorio lo permita.

Notas de producción

Un conflicto es una decisión de integración

Git informa de ediciones que se solapan.

No puede determinar qué comportamiento de negocio es el correcto.

La resolución de conflictos debe poder revisarse

Mantén las resoluciones acotadas y evita refactorizaciones no relacionadas.

Así la revisión de la pull request y la reversión son más seguras.

El historial de una rama compartida no debe reescribirse solo para evitar resolver conflictos

No sustituyas un merge compartido difícil por una estrategia destructiva de force-push.

Preserva la seguridad de la colaboración.

Las pruebas forman parte de la resolución de conflictos

Especialmente después de conflictos en:

  • contratos de API
  • código de base de datos
  • configuración
  • archivos de build
  • manifiestos de dependencias
  • modelos de serialización

La resolución asistida por herramientas sigue requiriendo criterio

Los botones del IDE como:

Accept Current
Accept Incoming
Accept Both

son operaciones de edición, no decisiones de arquitectura.

La frecuencia de los conflictos es una señal sobre el flujo de trabajo

Los conflictos grandes y repetidos pueden indicar que:

  • las ramas viven demasiado tiempo
  • los equipos modifican los mismos módulos a la vez
  • las refactorizaciones son demasiado amplias
  • la integración se produce demasiado tarde

Corregir el flujo de trabajo puede aportar más valor que dominar los comandos para resolver conflictos.

Errores comunes

1. Elegir ours/theirs sin comprobar la operación

Durante un rebase es especialmente fácil equivocarse con el modelo mental.

2. Hacer clic en «Accept Both» de forma automática

Ambos bloques pueden duplicar lógica o producir un comportamiento no válido.

3. Añadir un archivo al área de preparación antes de verificar la resolución

git add significa que Git lo considera resuelto.

Revisa primero.

4. Ejecutar reset --hard cuando aparece un conflicto

La mayoría de los conflictos pueden resolverse o abortarse de forma segura sin destruir el trabajo local.

5. Usar rebase --skip para evitar conflictos difíciles

Esto descarta el commit reaplicado.

6. Dejar marcadores de conflicto en el código fuente

Busca antes de hacer commit.

7. Resolver archivos generados manualmente sin revisar el flujo de generación

Regenerarlos puede ser más seguro y reproducible.

8. Tratar un merge limpio de Git como una combinación correcta de la aplicación

Pueden quedar conflictos semánticos.

9. Mezclar refactorizaciones no relacionadas con la resolución

Esto dificulta la revisión y la reversión.

10. Continuar antes de haber resuelto todas las rutas pendientes

Usa git status y la consulta de archivos sin fusionar para verificarlo.

Siguiente paso

Usa la operación y el síntoma para elegir la siguiente acción.

  • Conflicto de merge normal → resuelve los archivos, añádelos al área de preparación, revisa, prueba y luego haz commit.
  • Conflicto de rebase → resuelve, añade al área de preparación y ejecuta git rebase --continue.
  • Conflicto de cherry-pick → resuelve, añade al área de preparación y ejecuta git cherry-pick --continue.
  • Conflicto de revert → resuelve el cambio inverso previsto y luego ejecuta git revert --continue.
  • Rama equivocada o dirección de integración equivocada → aborta la operación.
  • ours/theirs resulta confuso → inspecciona las etapas del índice y el contenido real de los archivos.
  • Conflictos en archivos generados o de bloqueo → resuelve las entradas de referencia y regenera cuando corresponda.
  • Los conflictos son inesperadamente masivos → inspecciona el grafo de ramas y la base del merge antes de continuar.
  • Git no informa de conflictos, pero las pruebas fallan → investiga los conflictos semánticos.
  • Crees que el trabajo con conflictos dañó el historial → inspecciona git reflog y crea una rama de recuperación antes de hacer más cambios.

← Todas las guías rápidas