Explorar guías rápidas · Git
Ramas y merge
Crea, actualiza, compara, integra con merge y limpia ramas de Git de forma segura, preservando el historial compartido y evitando divergencias accidentales o resoluciones de conflictos destructivas.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Crear una rama de funcionalidad a partir de un main actualizado
- 2. Crear una rama a partir de una base remota concreta
- 3. Mostrar la rama actual
- 4. Listar ramas
- 5. Cambiar de rama de forma segura
- 6. Renombrar la rama actual
- 7. Comparar los commits de la rama de funcionalidad con main
- 8. Ver los commits de main que tu rama no tiene
- 9. Comparar los cambios de código con main
- 10. Mostrar solo los archivos modificados
- 11. Hacer fetch antes de decidir cómo actualizar
- 12. Hacer merge del main más reciente en la rama de funcionalidad
- 13. Hacer rebase de la rama de funcionalidad sobre el main más reciente
- 14. Entender merge frente a rebase
- 15. Hacer merge de otra rama en la rama actual
- 16. Hacer merge fast-forward cuando sea posible
- 17. Forzar un commit de merge de forma intencional
- 18. Anticipar si un merge será sencillo
- 19. Abortar un merge en curso
- 20. Detectar un merge activo
- 21. Resolver los conflictos de merge de forma deliberada
- 22. Listar los archivos en conflicto
- 23. Inspeccionar los fragmentos en conflicto
- 24. Entender ours frente a theirs durante un merge
- 25. Preparar los archivos resueltos
- 26. Continuar el merge después de los conflictos
- 27. Hacer merge de una rama después de su revisión
- 28. Combinar el trabajo de la funcionalidad en un solo commit local
- 29. Entender las ventajas y desventajas del squash merge
- 30. Hacer push de una nueva rama de funcionalidad
- 31. Hacer push después de hacer merge de main en una rama de funcionalidad
- 32. Hacer push después de hacer rebase de una rama de funcionalidad remota
- 33. Evitar hacer rebase de ramas de integración compartidas
- 34. Eliminar de forma segura una rama local ya integrada
- 35. Comprobar los commits sin integrar antes de eliminar
- 36. Forzar la eliminación de una rama local solo cuando sea necesario
- 37. Eliminar una rama remota
- 38. Depurar ramas de seguimiento remoto obsoletas
- 39. Encontrar ramas locales ya integradas en main
- 40. Encontrar ramas locales no integradas en main
- 41. Entender las ramas de seguimiento remoto
- 42. Configurar el upstream de una rama
- 43. Inspeccionar el estado por delante/por detrás
- 44. Encontrar la base de merge
- 45. Mostrar el grafo de ramas
- 46. Comparar directamente las puntas de dos ramas
- 47. No hacer merge de un main desactualizado por accidente
- 48. Crear una rama de respaldo antes de cambios complejos en el historial
- 49. Usar el reflog si un movimiento de rama sale mal
- 50. Mantener enfocadas las ramas de funcionalidad
- Qué significa el resultado
- Qué revisar
- La rama de funcionalidad tiene commits inesperados
- El merge genera muchos conflictos
- El merge indica «Already up to date»
- La rama remota cambió después de tu rebase
- Se rechaza la eliminación de la rama
- El mismo conflicto aparece una y otra vez
- Notas de producción
- La política de ramas debe ajustarse a la forma de colaborar del equipo
- Las ramas compartidas deben evitar reescribir el historial
- Las ramas de corta duración reducen el costo de los conflictos
- Resolver conflictos de merge es revisar código
- El CI/CD suele ejecutarse sobre el estado de la rama, no sobre la intención
- Las ramas de seguimiento remoto son instantáneas
- Errores comunes
- 1. Crear una rama de funcionalidad a partir de un main desactualizado
- 2. Hacer merge estando en la rama equivocada
- 3. Hacer rebase de una rama que tus compañeros ya usan
- 4. Hacer force push después de un merge normal
- 5. Elegir --ours o --theirs a ciegas
- 6. Eliminar una rama con -D sin comprobar sus commits propios
- 7. Tratar el squash merge como si fuera idéntico a un merge normal
- 8. Comparar las puntas de las ramas cuando en realidad quieres solo los cambios de la funcionalidad
- 9. Suponer que origin/main está al día sin hacer fetch
- 10. Mantener abiertas las ramas de funcionalidad demasiado tiempo
- Siguiente paso
- Para profundizar
Problema
Necesitas trabajar en cambios en paralelo sin romper la rama compartida.
Los flujos de trabajo de ingeniería típicos incluyen:
- crear una rama de funcionalidad a partir de la base correcta
- mantener actualizada la rama de funcionalidad
- comparar la rama con
main - hacer merge de los cambios de forma segura
- resolver los conflictos de forma deliberada
- evitar commits de merge accidentales
- limpiar las ramas locales y remotas
- entender cuándo un merge es más seguro que un rebase
El objetivo es mantener un historial de ramas comprensible y el trabajo compartido a salvo.
Respuesta rápida
Para una rama de funcionalidad normal:
git switch main
git pull --ff-only
git switch -c feature/report-engine
Trabaja y haz commit:
git add -p
git commit -m "Add report engine endpoint"
Antes de hacer merge:
git fetch origin
git diff origin/main...HEAD
git log --oneline origin/main..HEAD
Actualiza la rama de funcionalidad según la política que prefiera tu equipo:
git merge origin/main
o bien:
git rebase origin/main
Después, haz push:
git push -u origin feature/report-engine
En un historial de rama compartido, un merge o un revert suele ser más seguro que reescribir commits que tus compañeros quizá ya estén usando.
Código / comandos
1. Crear una rama de funcionalidad a partir de un main actualizado
git switch main
git pull --ff-only
git switch -c feature/report-engine
Así evitas crear la rama a partir de un main local desactualizado.
Usa --ff-only para evitar crear un commit de merge inesperado al actualizar el main local.
2. Crear una rama a partir de una base remota concreta
git fetch origin
git switch -c feature/report-engine origin/main
Úsalo cuando quieras que la rama parta directamente del main de seguimiento remoto (remote-tracking) más reciente.
3. Mostrar la rama actual
git branch --show-current
Úsalo antes de hacer commit o merge si tienes cualquier duda sobre dónde estás.
4. Listar ramas
Locales:
git branch
Locales + de seguimiento remoto:
git branch -a
Con el seguimiento del upstream:
git branch -vv
Usa -vv para ver si la rama va por delante o por detrás de su upstream.
5. Cambiar de rama de forma segura
git switch feature/report-engine
Git puede negarse si se sobrescribirían cambios sin commit.
No fuerces el cambio de rama solo para «saltarte» la advertencia.
Haz commit, haz stash o resuelve el estado del árbol de trabajo de forma intencional.
6. Renombrar la rama actual
git branch -m feature/new-name
Si ya hiciste push de la rama antigua, la rama remota no se renombra automáticamente.
Normalmente harás push del nuevo nombre y eliminarás la rama remota antigua por separado.
7. Comparar los commits de la rama de funcionalidad con main
git log --oneline origin/main..HEAD
Muestra los commits que tiene tu rama actual y que origin/main no tiene.
Úsalo antes de abrir o actualizar una pull request.
8. Ver los commits de main que tu rama no tiene
git log --oneline HEAD..origin/main
Si devuelve commits, tu rama va por detrás de origin/main.
9. Comparar los cambios de código con main
git diff origin/main...HEAD
La sintaxis de tres puntos compara tu rama con la base de merge (merge base).
Normalmente representa el conjunto de cambios introducido por la rama de funcionalidad.
10. Mostrar solo los archivos modificados
git diff --name-status origin/main...HEAD
Útil para comprobar rápidamente el alcance.
Ejemplo:
M src/api.py
A src/report_engine.py
D src/legacy_report.py
11. Hacer fetch antes de decidir cómo actualizar
git fetch origin
Actualiza las referencias de seguimiento remoto sin modificar tu árbol de trabajo.
Después, inspecciona:
git log --oneline --graph --decorate --all -20
No hagas merge ni rebase contra un origin/main desactualizado.
12. Hacer merge del main más reciente en la rama de funcionalidad
git merge origin/main
Úsalo cuando:
- se prefiere preservar el historial
- la rama ya está compartida
- reescribir commits sería disruptivo
Puede crear un commit de merge si los historiales divergieron.
13. Hacer rebase de la rama de funcionalidad sobre el main más reciente
git rebase origin/main
Úsalo cuando:
- la rama es principalmente tuya
- el flujo de trabajo del equipo prefiere un historial lineal
- es aceptable reescribir los commits de la rama de funcionalidad
Evita hacer rebase a la ligera de commits de los que tus compañeros ya dependen.
14. Entender merge frente a rebase
Conceptualmente:
MERGE
A---B---C main
\ \
D---E---M feature
frente a:
REBASE
A---B---C main
\
D'---E' feature
El rebase crea nuevos identificadores de commit para los commits que vuelve a aplicar.
El merge preserva los commits originales y agrega historial de merge cuando hace falta.
15. Hacer merge de otra rama en la rama actual
git merge feature/other-work
Confirma siempre primero la rama actual:
git branch --show-current
Git hace merge en la rama en la que te encuentras.
16. Hacer merge fast-forward cuando sea posible
Si la rama actual no tiene commits propios:
git merge --ff-only feature/report-engine
Mueve el puntero de la rama hacia delante sin crear un commit de merge.
Si el fast-forward es imposible, Git se detiene en lugar de aplicar otra estrategia de merge.
17. Forzar un commit de merge de forma intencional
git merge --no-ff feature/report-engine
Úsalo solo si el flujo de trabajo del repositorio preserva intencionalmente los commits de merge de las ramas de funcionalidad.
No agregues commits de merge por defecto cuando el equipo prefiere un historial lineal.
18. Anticipar si un merge será sencillo
git log --oneline --graph --decorate --all -30
y:
git diff HEAD...feature/report-engine
Git no tiene una simulación (dry-run) perfecta para todos los resultados de merge, pero inspeccionar primero la divergencia reduce las sorpresas.
19. Abortar un merge en curso
git merge --abort
Úsalo cuando:
- empezaste desde la rama equivocada
- los conflictos son más amplios de lo esperado
- necesitas volver al estado previo al merge
No restablezcas archivos manualmente mientras haya un merge activo, a menos que entiendas las consecuencias.
20. Detectar un merge activo
git status
Git indicará que hay conflictos o que hay un merge en curso.
git status debería ser el primer comando tras un merge interrumpido.
21. Resolver los conflictos de merge de forma deliberada
Un archivo en conflicto puede contener:
<<<<<<< HEAD
versión de la rama actual
=======
versión de la rama entrante
>>>>>>> feature/other-work
Edita el archivo hasta obtener el resultado final deseado.
Después:
git add path/to/file
Cuando todos los conflictos estén resueltos:
git commit
o deja que Git complete el merge según el estado actual.
No dejes marcadores de conflicto en el código del que hagas commit.
22. Listar los archivos en conflicto
git diff --name-only --diff-filter=U
Úsalo durante la resolución de un conflicto grande.
23. Inspeccionar los fragmentos en conflicto
git diff
Durante un conflicto de merge, Git muestra las secciones sin resolver.
Úsalo antes de elegir cualquiera de los dos lados.
24. Entender ours frente a theirs durante un merge
Durante un merge:
ours
→ rama actual
theirs
→ rama que se está integrando con merge
Ejemplo:
git checkout --ours path/to/file
o la forma moderna con restore:
git restore --ours path/to/file
No uses --ours / --theirs a ciegas.
Una resolución correcta suele combinar ambas versiones.
25. Preparar los archivos resueltos
git add src/app.py
git add README.md
Después, verifica:
git status
El merge solo está completo cuando todos los conflictos están resueltos y agregados al área de preparación (staging area).
26. Continuar el merge después de los conflictos
Normalmente:
git commit
Git propondrá un mensaje de commit de merge.
Revísalo antes de guardarlo.
27. Hacer merge de una rama después de su revisión
Flujo local típico:
git switch main
git pull --ff-only
git merge --ff-only feature/report-engine
Solo funciona si la rama de funcionalidad ya está basada directamente en el main más reciente.
De lo contrario, la política de merge del repositorio puede exigir:
- commit de merge
- squash merge
- rebase merge
A menudo, esto lo gestiona la plataforma de alojamiento de Git.
28. Combinar el trabajo de la funcionalidad en un solo commit local
git merge --squash feature/report-engine
git commit -m "Add report engine"
Aplica los cambios de la funcionalidad al árbol de trabajo y al índice sin crear una relación de merge con la rama de funcionalidad.
Úsalo solo cuando el historial con squash sea la política prevista.
29. Entender las ventajas y desventajas del squash merge
El squash produce un único commit nuevo que contiene el diff final.
Ventajas:
- historial de main compacto
- revert sencillo a nivel de funcionalidad
Desventajas:
- los commits individuales de la funcionalidad no se conservan en
main - Git no registra una relación de merge normal con la rama de funcionalidad
Esto afecta a las comparaciones de ramas posteriores y al comportamiento de merges repetidos.
30. Hacer push de una nueva rama de funcionalidad
git push -u origin feature/report-engine
Una vez configurado el upstream:
git push
31. Hacer push después de hacer merge de main en una rama de funcionalidad
git push
Un merge normal no reescribe los commits existentes de la funcionalidad, así que un push normal suele bastar.
32. Hacer push después de hacer rebase de una rama de funcionalidad remota
Si hiciste rebase de commits de los que ya habías hecho push:
git push --force-with-lease
Prefiere esto a:
git push --force
Úsalo solo cuando sea aceptable reescribir esa rama de funcionalidad.
33. Evitar hacer rebase de ramas de integración compartidas
No hagas rebase a la ligera de:
main
develop
release
ramas compartidas del equipo
porque los identificadores de commit cambian y tus colaboradores quizá ya hayan basado su trabajo en ellas.
34. Eliminar de forma segura una rama local ya integrada
git branch -d feature/report-engine
-d se niega a eliminar una rama que Git no considera completamente integrada con merge.
Es más seguro que -D.
35. Comprobar los commits sin integrar antes de eliminar
git log main..feature/report-engine
Si muestra commits, verifica que se puedan descartar intencionalmente antes de eliminar la rama.
36. Forzar la eliminación de una rama local solo cuando sea necesario
git branch -D feature/report-engine
Puede eliminar el nombre de la rama aunque queden commits propios.
Úsalo solo después de confirmar que esos commits se conservan en otro lugar o que ya no se necesitan.
37. Eliminar una rama remota
git push origin --delete feature/report-engine
La eliminación remota afecta a otros colaboradores.
Hazla después del merge o del cierre, según el flujo de trabajo del equipo.
38. Depurar ramas de seguimiento remoto obsoletas
git fetch --prune
Elimina referencias obsoletas como:
origin/feature/old-branch
cuando la rama remota correspondiente ya no existe.
No elimina ramas locales.
39. Encontrar ramas locales ya integradas en main
git branch --merged main
Úsalo como ayuda para la limpieza.
Aun así, verifica las ramas importantes antes de eliminarlas.
40. Encontrar ramas locales no integradas en main
git branch --no-merged main
Ayuda a identificar trabajo que todavía podría ser único.
41. Entender las ramas de seguimiento remoto
origin/main no es la propia rama remota.
Es la última vista de la rama remota que tu repositorio local obtuvo con fetch.
Actualízala con:
git fetch origin
No supongas que origin/main está al día si no has hecho fetch recientemente.
42. Configurar el upstream de una rama
git branch \
--set-upstream-to=origin/feature/report-engine \
feature/report-engine
Normalmente git push -u se encarga de esto al hacer el primer push de una rama.
43. Inspeccionar el estado por delante/por detrás
git status
o bien:
git branch -vv
Para obtener el número exacto de commits:
git rev-list \
--left-right \
--count \
origin/main...HEAD
Ejemplo:
3 2
significa:
3 commits exclusivos de origin/main
2 commits exclusivos de HEAD
44. Encontrar la base de merge
git merge-base origin/main HEAD
Muestra el ancestro común que se usa en las comparaciones de tres puntos.
Útil para entender la divergencia entre ramas.
45. Mostrar el grafo de ramas
git log \
--oneline \
--graph \
--decorate \
--all \
-30
Úsalo cuando la relación entre ramas resulte confusa.
46. Comparar directamente las puntas de dos ramas
git diff main feature/report-engine
Compara las instantáneas de las puntas de las dos ramas.
Es distinto de:
git diff main...feature/report-engine
que compara desde la base de merge y suele ser más adecuado para revisar una rama de funcionalidad.
47. No hacer merge de un main desactualizado por accidente
Antes de hacer merge de una funcionalidad terminada en el main local:
git switch main
git fetch origin
git pull --ff-only
Después, haz el merge previsto.
Así evitas integrar sobre una base local desactualizada.
48. Crear una rama de respaldo antes de cambios complejos en el historial
git branch backup-before-integration
Hazlo antes de:
- un rebase arriesgado
- una resolución de conflictos complicada
- una cirugía de ramas locales
Crear una rama es barato y proporciona un punto de recuperación.
49. Usar el reflog si un movimiento de rama sale mal
git reflog
Encuentra el commit anterior:
git show <commit>
Crea una rama de recuperación:
git switch -c recovery <commit>
El reflog es especialmente útil después de un reset o un rebase accidental.
50. Mantener enfocadas las ramas de funcionalidad
Es preferible que:
feature/report-engine
contenga un único bloque de trabajo coherente.
Evita mezclar:
- refactorizaciones no relacionadas
- actualizaciones de dependencias
- formateo de todo el repositorio
- trabajo de funcionalidades distintas
Las ramas enfocadas producen merges más sencillos y menos conflictos.
Qué significa el resultado
| Operación | Comportamiento del historial | Uso típico |
|---|---|---|
git switch -c |
Crea un nuevo puntero de rama | Empezar un trabajo aislado |
git fetch |
Actualiza las referencias de seguimiento remoto | Inspeccionar el estado actual del remoto |
git merge |
Preserva ambos historiales | Integrar ramas de forma segura |
git merge --ff-only |
Solo mueve el puntero de la rama | Integración limpia con fast-forward |
git merge --no-ff |
Fuerza un commit de merge | Preservar el límite de la rama de funcionalidad |
git merge --squash |
Solo aplica el diff combinado | Un único commit para la funcionalidad |
git rebase |
Reescribe los identificadores de los commits reaplicados | Linealizar el historial de una funcionalidad privada |
git branch -d |
Elimina la referencia de la rama local ya integrada | Limpieza segura |
git push --delete |
Elimina la rama remota | Limpieza en el remoto |
git merge --abort |
Cancela el merge activo | Recuperarse de un merge equivocado o inseguro |
La decisión central es:
¿Necesitas preservar el historial compartido?
→ merge
¿Necesitas linealizar el historial de una funcionalidad privada?
→ un rebase puede encajar
Qué revisar
La rama de funcionalidad tiene commits inesperados
Ejecuta:
git log --oneline origin/main..HEAD
e inspecciona el grafo.
Puede que la rama se haya creado a partir de la base equivocada.
El merge genera muchos conflictos
Causas probables:
- rama de larga duración
- refactorización amplia que se solapa
- rama de funcionalidad desactualizada
- muchos cambios no relacionados en una sola rama
Resuelve primero la corrección del código y después plantéate cambiar el flujo de trabajo con ramas.
El merge indica «Already up to date»
Puede que estés en la rama equivocada o haciendo merge en la dirección equivocada.
Comprueba:
git branch --show-current
git log --oneline --graph --decorate --all -20
La rama remota cambió después de tu rebase
No la sobrescribas a ciegas.
Haz fetch e inspecciona si otra persona hizo push de cambios.
Se rechaza la eliminación de la rama
Git considera que la rama contiene commits que no se han integrado en el historial de destino.
Inspecciónalos antes de usar -D.
El mismo conflicto aparece una y otra vez
Una divergencia prolongada o rebases/cherry-picks repetidos pueden estar causando solapamientos recurrentes.
Plantéate usar ramas más pequeñas e integrar con más frecuencia.
Notas de producción
La política de ramas debe ajustarse a la forma de colaborar del equipo
No existe una política universalmente mejor.
Entre los patrones habituales están:
commits de merge
squash merge
rebase + fast-forward
Elige uno de forma deliberada y aplícalo de forma coherente.
Las ramas compartidas deben evitar reescribir el historial
Cuando otras personas dependen de los identificadores de commit, reescribirlos genera coordinación y riesgos innecesarios.
Las ramas de corta duración reducen el costo de los conflictos
Cuanto más tiempo diverge una rama de funcionalidad de main, más probable es tener que resolver conflictos grandes.
Integra con la frecuencia suficiente para que las diferencias sigan siendo manejables.
Resolver conflictos de merge es revisar código
Un conflicto no es solo un problema mecánico de Git.
El ingeniero debe entender el comportamiento combinado que se pretende.
El CI/CD suele ejecutarse sobre el estado de la rama, no sobre la intención
Antes de hacer merge, confirma:
- la rama correcta
- los commits esperados
- un árbol de trabajo limpio
- el estado de las pruebas y del build
- que no haya archivos agregados por accidente
Las ramas de seguimiento remoto son instantáneas
Haz siempre fetch antes de tomar decisiones de integración basadas en origin/*.
Errores comunes
1. Crear una rama de funcionalidad a partir de un main desactualizado
Empiezas con una divergencia evitable.
2. Hacer merge estando en la rama equivocada
Git hace merge en la rama actual.
Compruébalo primero.
3. Hacer rebase de una rama que tus compañeros ya usan
Reescribe los identificadores de commit y complica su historial.
4. Hacer force push después de un merge normal
Un merge normalmente no requiere force push.
5. Elegir --ours o --theirs a ciegas
Una resolución correcta del conflicto puede necesitar ambos lados.
6. Eliminar una rama con -D sin comprobar sus commits propios
Puedes perder el puntero de rama hacia trabajo no integrado.
7. Tratar el squash merge como si fuera idéntico a un merge normal
El squash no preserva la misma relación de ascendencia.
8. Comparar las puntas de las ramas cuando en realidad quieres solo los cambios de la funcionalidad
Para una revisión al estilo de una pull request, la comparación de tres puntos suele ser más útil.
9. Suponer que origin/main está al día sin hacer fetch
Las referencias de seguimiento remoto pueden estar desactualizadas.
10. Mantener abiertas las ramas de funcionalidad demasiado tiempo
Una divergencia prolongada aumenta la complejidad de los conflictos y de la revisión.
¿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.