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