Explorar guías rápidas · Git

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

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
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Crear una rama de funcionalidad a partir de un main actualizado
  5. 2. Crear una rama a partir de una base remota concreta
  6. 3. Mostrar la rama actual
  7. 4. Listar ramas
  8. 5. Cambiar de rama de forma segura
  9. 6. Renombrar la rama actual
  10. 7. Comparar los commits de la rama de funcionalidad con main
  11. 8. Ver los commits de main que tu rama no tiene
  12. 9. Comparar los cambios de código con main
  13. 10. Mostrar solo los archivos modificados
  14. 11. Hacer fetch antes de decidir cómo actualizar
  15. 12. Hacer merge del main más reciente en la rama de funcionalidad
  16. 13. Hacer rebase de la rama de funcionalidad sobre el main más reciente
  17. 14. Entender merge frente a rebase
  18. 15. Hacer merge de otra rama en la rama actual
  19. 16. Hacer merge fast-forward cuando sea posible
  20. 17. Forzar un commit de merge de forma intencional
  21. 18. Anticipar si un merge será sencillo
  22. 19. Abortar un merge en curso
  23. 20. Detectar un merge activo
  24. 21. Resolver los conflictos de merge de forma deliberada
  25. 22. Listar los archivos en conflicto
  26. 23. Inspeccionar los fragmentos en conflicto
  27. 24. Entender ours frente a theirs durante un merge
  28. 25. Preparar los archivos resueltos
  29. 26. Continuar el merge después de los conflictos
  30. 27. Hacer merge de una rama después de su revisión
  31. 28. Combinar el trabajo de la funcionalidad en un solo commit local
  32. 29. Entender las ventajas y desventajas del squash merge
  33. 30. Hacer push de una nueva rama de funcionalidad
  34. 31. Hacer push después de hacer merge de main en una rama de funcionalidad
  35. 32. Hacer push después de hacer rebase de una rama de funcionalidad remota
  36. 33. Evitar hacer rebase de ramas de integración compartidas
  37. 34. Eliminar de forma segura una rama local ya integrada
  38. 35. Comprobar los commits sin integrar antes de eliminar
  39. 36. Forzar la eliminación de una rama local solo cuando sea necesario
  40. 37. Eliminar una rama remota
  41. 38. Depurar ramas de seguimiento remoto obsoletas
  42. 39. Encontrar ramas locales ya integradas en main
  43. 40. Encontrar ramas locales no integradas en main
  44. 41. Entender las ramas de seguimiento remoto
  45. 42. Configurar el upstream de una rama
  46. 43. Inspeccionar el estado por delante/por detrás
  47. 44. Encontrar la base de merge
  48. 45. Mostrar el grafo de ramas
  49. 46. Comparar directamente las puntas de dos ramas
  50. 47. No hacer merge de un main desactualizado por accidente
  51. 48. Crear una rama de respaldo antes de cambios complejos en el historial
  52. 49. Usar el reflog si un movimiento de rama sale mal
  53. 50. Mantener enfocadas las ramas de funcionalidad
  54. Qué significa el resultado
  55. Qué revisar
  56. La rama de funcionalidad tiene commits inesperados
  57. El merge genera muchos conflictos
  58. El merge indica «Already up to date»
  59. La rama remota cambió después de tu rebase
  60. Se rechaza la eliminación de la rama
  61. El mismo conflicto aparece una y otra vez
  62. Notas de producción
  63. La política de ramas debe ajustarse a la forma de colaborar del equipo
  64. Las ramas compartidas deben evitar reescribir el historial
  65. Las ramas de corta duración reducen el costo de los conflictos
  66. Resolver conflictos de merge es revisar código
  67. El CI/CD suele ejecutarse sobre el estado de la rama, no sobre la intención
  68. Las ramas de seguimiento remoto son instantáneas
  69. Errores comunes
  70. 1. Crear una rama de funcionalidad a partir de un main desactualizado
  71. 2. Hacer merge estando en la rama equivocada
  72. 3. Hacer rebase de una rama que tus compañeros ya usan
  73. 4. Hacer force push después de un merge normal
  74. 5. Elegir --ours o --theirs a ciegas
  75. 6. Eliminar una rama con -D sin comprobar sus commits propios
  76. 7. Tratar el squash merge como si fuera idéntico a un merge normal
  77. 8. Comparar las puntas de las ramas cuando en realidad quieres solo los cambios de la funcionalidad
  78. 9. Suponer que origin/main está al día sin hacer fetch
  79. 10. Mantener abiertas las ramas de funcionalidad demasiado tiempo
  80. Siguiente paso
  81. 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.

Siguiente paso

Usa el estado de la rama para elegir la siguiente acción.

  • Empiezas un trabajo nuevo → actualiza main y después crea una nueva rama de funcionalidad.
  • Necesitas ver el alcance de la rama → usa git log origin/main..HEAD y git diff origin/main...HEAD.
  • La rama de funcionalidad va por detrás de main → haz merge o rebase según la política del equipo.
  • La rama ya está compartida → prefiere el merge a reescribir el historial.
  • Una rama de funcionalidad privada necesita un historial lineal → un rebase puede encajar.
  • Aparecen conflictos de merge → resuélvelos de forma intencional, agrégalos al área de preparación y completa o aborta el merge.
  • La rama ya está integrada → elimina la rama local con -d y después la remota, si corresponde.
  • El historial de la rama parece incorrecto → inspecciona el grafo y la base de merge antes de cambiar nada.
  • Necesitas reescribir commits de forma limpia → pasa a Referencia rápida de rebase.
  • Necesitas recuperarte de errores con ramas → pasa a Deshacer cambios de forma segura.

← Todas las guías rápidas