Explorar guías rápidas · Git

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

Referencia rápida de rebase

Haz rebase de ramas de Git de forma segura para reaplicar commits locales sobre una nueva base, resolver conflictos con criterio, limpiar el historial privado y recuperarte cuando un rebase sale mal.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Revisa el árbol de trabajo antes del rebase
  5. 2. Obtén primero el estado más reciente del remoto
  6. 3. Haz rebase de la rama actual sobre la versión más reciente de main
  7. 4. Haz rebase sobre una rama main local
  8. 5. Comprueba qué se va a reaplicar
  9. 6. Inspecciona el grafo de ramas
  10. 7. Encuentra la base de merge
  11. 8. Resuelve un conflicto de rebase
  12. 9. Lista los archivos sin resolver
  13. 10. Inspecciona el contenido del conflicto
  14. 11. Continúa después de resolver los conflictos
  15. 12. Omite un commit solo cuando realmente ya no sea necesario
  16. 13. Cancela el rebase
  17. 14. Sal de un rebase sin restablecer el estado de la rama
  18. 15. Haz push de una rama de funcionalidad tras el rebase
  19. 16. Por qué --force-with-lease es más seguro
  20. 17. No hagas rebase a la ligera de ramas de integración compartidas
  21. 18. Haz un rebase interactivo de los commits recientes
  22. 19. Acciones comunes del rebase interactivo
  23. 20. Cambia el mensaje de un commit
  24. 21. Combina commits relacionados con squash
  25. 22. Usa fixup para los commits de limpieza
  26. 23. Elimina un commit local no deseado
  27. 24. Reordena commits
  28. 25. Edita un commit durante un rebase interactivo
  29. 26. Divide un commit en varios commits
  30. 27. Usa autosquash con commits fixup
  31. 28. Crea un commit fixup a partir de los cambios actuales
  32. 29. Haz rebase de una rama sobre una base diferente
  33. 30. Inspecciona los commits antes de usar --onto
  34. 31. Haz rebase de una rama mientras estás en otra
  35. 32. Conserva la topología de merges con --rebase-merges
  36. 33. Evita hacer rebase a la ligera de historial compartido con muchos merges
  37. 34. Comprueba el estado actual del rebase
  38. 35. Edita la lista de tareas pendiente del rebase
  39. 36. Recupérate de un rebase accidental con el reflog
  40. 37. Crea una rama de respaldo antes del rebase
  41. 38. Compara antes y después del rebase
  42. 39. Verifica el contenido de la funcionalidad después del rebase
  43. 40. Ejecuta las pruebas después de resolver los conflictos
  44. 41. Haz rebase sobre la versión más reciente de main remota sin cambiar de rama
  45. 42. Configura deliberadamente el comportamiento de pull
  46. 43. Haz rebase con autostash cuando corresponda
  47. 44. Evita hacer rebase con archivos generados o de entorno sin commit
  48. 45. Reaplica solo los commits que pertenecen a la funcionalidad
  49. 46. No hagas rebase solo para que el historial «parezca limpio»
  50. 47. Entiende que los identificadores de commit cambian
  51. 48. El rebase puede reaplicar conflictos varias veces
  52. 49. Usa rerere solo si tu equipo lo entiende
  53. 50. Usa merge cuando el riesgo del rebase supere el beneficio
  54. Qué significa el resultado
  55. Qué revisar
  56. El push se rechaza tras un rebase correcto
  57. El rebase incluye commits inesperados
  58. El mismo conflicto aparece una y otra vez
  59. El rebase terminó, pero el diff de la funcionalidad cambió
  60. Desapareció un commit
  61. Un compañero dice que su rama se rompió después de tu push forzado
  62. Notas de producción
  63. El rebase es más seguro antes de compartir
  64. Force-with-lease debe seguir siendo intencionado
  65. CI/CD hace referencia a identificadores de commit
  66. La resolución de conflictos puede cambiar el comportamiento
  67. El rebase interactivo sirve para diseñar el historial
  68. Las ramas de respaldo y el reflog hacen más segura la reescritura local
  69. Errores comunes
  70. 1. Hacer rebase sin hacer fetch antes
  71. 2. Hacer rebase de ramas compartidas
  72. 3. Hacer push forzado con --force
  73. 4. Usar --skip solo para sortear un conflicto
  74. 5. Tratar la resolución de conflictos como algo mecánico
  75. 6. Usar el rebase interactivo en historial ya compartido sin coordinación
  76. 7. Reordenar mal commits dependientes
  77. 8. Combinar commits no relacionados
  78. 9. Suponer que el rebase conserva automáticamente el contenido exacto
  79. 10. Usar rebase cuando merge es más sencillo y seguro
  80. Siguiente paso
  81. Para profundizar

Problema

Necesitas actualizar o limpiar una rama de funcionalidad sin introducir commits de merge innecesarios.

Los casos de uso típicos del rebase incluyen:

  • reaplicar una rama de funcionalidad sobre la versión más reciente de main
  • mantener lineal el historial de una rama privada
  • reordenar, combinar (squash) o editar commits locales
  • eliminar commits accidentales antes de abrir una pull request
  • resolver conflictos mientras se reaplican los commits
  • recuperarte de un rebase fallido o incorrecto

El principal riesgo es que el rebase reescribe el historial de commits.

Eso es seguro en ramas de funcionalidad privadas o reescritas de forma intencionada, pero peligroso en commits compartidos de los que tus compañeros ya dependen.

Respuesta rápida

Actualiza una rama de funcionalidad privada sobre la versión más reciente de main:

git status
git fetch origin
git rebase origin/main

Si aparecen conflictos:

git status
# edit conflicted files
git add path/to/resolved-file
git rebase --continue

Cancela si es necesario:

git rebase --abort

Si la rama ya se subió con push y reescribirla es aceptable:

git push --force-with-lease

La regla central es:

Historial privado de una funcionalidad
→ el rebase suele ser seguro

Historial compartido
→ evita reescribirlo salvo que el equipo lo coordine explícitamente

Código / comandos

1. Revisa el árbol de trabajo antes del rebase

git status

Es preferible empezar con un árbol de trabajo (working tree) limpio.

Si hay cambios no relacionados:

git stash push -u -m "WIP before rebase"

o haz commit de ellos en la rama adecuada.

No empieces un rebase complejo con trabajo sin commit no relacionado, salvo que entiendas exactamente cómo lo gestionará Git.


2. Obtén primero el estado más reciente del remoto

git fetch origin

Esto actualiza:

origin/main
origin/develop
origin/feature/...

sin modificar tu árbol de trabajo actual.

No hagas rebase sobre una vista local desactualizada de la rama remota.


3. Haz rebase de la rama actual sobre la versión más reciente de main

git rebase origin/main

Conceptualmente:

Antes:

A---B---C  origin/main
     \
      D---E  feature

Después:

A---B---C  origin/main
         \
          D'---E'  feature

D' y E' son commits nuevos con nuevos identificadores de commit.


4. Haz rebase sobre una rama main local

Si la rama main local ya está actualizada:

git rebase main

Flujo de trabajo más seguro:

git switch main
git pull --ff-only
git switch feature/report-engine
git rebase main

Usar origin/main después de git fetch suele ser más directo.


5. Comprueba qué se va a reaplicar

Antes del rebase:

git log --oneline origin/main..HEAD

Esto muestra los commits exclusivos de tu rama actual.

Esos son los commits que Git normalmente reaplicará.


6. Inspecciona el grafo de ramas

git log \
  --oneline \
  --graph \
  --decorate \
  --all \
  -30

Úsalo cuando la ascendencia de las ramas no sea evidente.

No hagas rebase hasta entender qué rama es la base y qué commits son exclusivos de tu rama.


7. Encuentra la base de merge

git merge-base origin/main HEAD

Esto identifica el ancestro común.

Es útil cuando una rama se creó a partir de una base inesperada.


8. Resuelve un conflicto de rebase

Cuando Git se detenga:

git status

Abre los archivos en conflicto y resuélvelos según el contenido final que buscas.

Después, añádelos al área de preparación (staging area):

git add path/to/file

Continúa:

git rebase --continue

Repite hasta que se hayan reaplicado todos los commits.


9. Lista los archivos sin resolver

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

Úsalo durante la resolución de un conflicto grande.


10. Inspecciona el contenido del conflicto

git diff

Los marcadores de conflicto pueden tener este aspecto:

<<<<<<< HEAD
versión de la rama base
=======
versión del commit reaplicado
>>>>>>> commit-message

Durante un rebase, el significado de ours y theirs puede resultar poco intuitivo, porque Git está reaplicando commits sobre la nueva base.

No elijas un lado de forma mecánica.

Resuelve el código en función del estado final deseado.


11. Continúa después de resolver los conflictos

git add src/app.py
git rebase --continue

Si Git abre el editor del mensaje de commit, revisa el mensaje antes de continuar.


12. Omite un commit solo cuando realmente ya no sea necesario

git rebase --skip

Úsalo solo si los cambios del commit actual ya están presentes o se descartan de forma intencionada.

Omitir un commit lo elimina de la rama tras el rebase.

No uses --skip simplemente para sortear un conflicto.


13. Cancela el rebase

git rebase --abort

Esto devuelve la rama a su estado anterior al rebase.

Úsalo cuando:

  • partiste de la base equivocada
  • los conflictos revelan que el enfoque no es seguro
  • necesitas replantear el historial de la rama

Es preferible cancelar que improvisar resets destructivos durante un rebase en curso.


14. Sal de un rebase sin restablecer el estado de la rama

git rebase --quit

Esto detiene la maquinaria del rebase sin restaurar necesariamente el estado original de la rama.

Úsalo solo si entiendes la diferencia con:

git rebase --abort

En la mayoría de los escenarios de recuperación, --abort es la opción más segura.


15. Haz push de una rama de funcionalidad tras el rebase

Si la rama nunca se subió con push:

git push -u origin feature/report-engine

Si ya se subió y reescribirla es aceptable:

git push --force-with-lease

Prefiere esto a:

git push --force

16. Por qué --force-with-lease es más seguro

--force-with-lease comprueba que la rama remota sigue apuntando al commit que tu repositorio local espera.

Si otra persona subió commits nuevos, el push forzado se rechaza.

Esto reduce la posibilidad de sobrescribir el trabajo de otro desarrollador.

No hace que reescribir el historial esté libre de riesgos.


17. No hagas rebase a la ligera de ramas de integración compartidas

Evita reescribir:

main
develop
release
ramas compartidas del equipo

salvo que el flujo de trabajo del repositorio lo exija y lo coordine explícitamente.

El rebase es más apropiado para ramas de funcionalidad privadas o que se pueden reescribir de forma intencionada.


18. Haz un rebase interactivo de los commits recientes

git rebase -i HEAD~5

Esto abre los últimos cinco commits en una lista de tareas (todo list) interactiva.

Ejemplo:

pick a1b2c3d Add report endpoint
pick d4e5f6a Fix typo
pick 1112223 Add validation
pick 3334445 Debug logging
pick 5556667 Remove debug logging

Puedes cambiar la acción de cada commit.


19. Acciones comunes del rebase interactivo

Comandos típicos:

pick
reword
edit
squash
fixup
drop

Uso:

pick
→ conservar el commit

reword
→ conservar los cambios, editar el mensaje

edit
→ pausar para que puedas modificar el commit

squash
→ combinar con el commit anterior y editar el mensaje combinado

fixup
→ combinar con el commit anterior y descartar el mensaje de este commit

drop
→ eliminar el commit

20. Cambia el mensaje de un commit

Rebase interactivo:

git rebase -i HEAD~3

Cambia:

pick a1b2c3d bad message

por:

reword a1b2c3d bad message

Git se detendrá para que puedas editar el mensaje.


21. Combina commits relacionados con squash

Ejemplo de lista de tareas:

pick a1b2c3d Add report endpoint
squash d4e5f6a Add validation
squash 1112223 Fix endpoint naming

Git combina los commits en uno solo.

Úsalo cuando el historial final resulte más claro como un único cambio lógico.

No combines trabajo no relacionado solo para reducir el número de commits.


22. Usa fixup para los commits de limpieza

Ejemplo:

pick a1b2c3d Add report endpoint
fixup d4e5f6a Fix typo
fixup 1112223 Remove debug print

El commit final conserva el mensaje del primer commit.

Es útil para los pequeños commits correctivos hechos durante el desarrollo.


23. Elimina un commit local no deseado

Rebase interactivo:

pick a1b2c3d Add endpoint
drop d4e5f6a Add temporary debug file
pick 1112223 Add tests

O borra la línea en la lista de tareas.

Úsalo solo con commits no publicados o cuando sea aceptable una reescritura coordinada del historial.


24. Reordena commits

El rebase interactivo permite cambiar el orden de los commits:

pick 1112223 Add data model
pick a1b2c3d Add endpoint
pick d4e5f6a Add tests

en lugar de:

pick a1b2c3d Add endpoint
pick 1112223 Add data model
pick d4e5f6a Add tests

Reordena solo si los commits posteriores se siguen aplicando limpiamente y el historial resultante sigue siendo lógicamente correcto.


25. Edita un commit durante un rebase interactivo

Cambia:

pick a1b2c3d Add endpoint

por:

edit a1b2c3d Add endpoint

Cuando Git se detenga:

# modify files
git add path/to/file
git commit --amend
git rebase --continue

Úsalo para corregir el contenido de un commit local más antiguo.


26. Divide un commit en varios commits

Empieza:

git rebase -i HEAD~5

Marca el commit objetivo:

edit

Cuando Git se detenga:

git reset HEAD^

Esto mantiene los cambios en el árbol de trabajo, pero elimina el commit.

Después, prepara los cambios y haz commit en partes lógicas:

git add -p
git commit -m "Add report model"

git add -p
git commit -m "Add report API"

Luego:

git rebase --continue

Úsalo solo en historial local que no se haya compartido.


27. Usa autosquash con commits fixup

Crea un commit fixup:

git commit --fixup=<commit>

Luego:

git rebase -i --autosquash origin/main

Git coloca automáticamente el commit fixup junto a su commit objetivo y lo marca como fixup.

Es útil durante el desarrollo activo de una funcionalidad.


28. Crea un commit fixup a partir de los cambios actuales

git add path/to/file
git commit --fixup=a1b2c3d

Más adelante:

git rebase -i --autosquash origin/main

Así mantienes un desarrollo ágil y, aun así, produces un historial limpio antes de la revisión.


29. Haz rebase de una rama sobre una base diferente

Sintaxis avanzada:

git rebase --onto <new-base> <old-base> <branch>

Ejemplo:

git rebase \
  --onto origin/main \
  origin/develop \
  feature/report-engine

Esto le indica a Git:

Toma los commits de feature/report-engine
que van después de origin/develop
y reaplícalos sobre origin/main

Úsalo cuando una rama se creó a partir de la base equivocada o necesita moverse entre líneas de release.


30. Inspecciona los commits antes de usar --onto

Antes de ejecutar:

git rebase --onto ...

inspecciona:

git log --oneline <old-base>..<branch>

Esos son los commits que probablemente se reaplicarán.

Si el rango es incorrecto, no sigas adelante.


31. Haz rebase de una rama mientras estás en otra

Las versiones modernas de Git admiten:

git rebase origin/main feature/report-engine

Esto hace checkout interno de la rama indicada y le aplica el rebase.

Para mayor claridad en los flujos manuales, suele ser más fácil razonar si primero cambias a esa rama.


32. Conserva la topología de merges con --rebase-merges

git rebase --rebase-merges origin/main

Úsalo cuando la rama de funcionalidad contiene commits de merge significativos que deben reconstruirse en lugar de aplanarse.

Es un flujo de trabajo avanzado.

No lo uses salvo que importe conservar la topología de las ramas.


33. Evita hacer rebase a la ligera de historial compartido con muchos merges

Los commits de merge pueden recoger decisiones de integración.

Aplanarlos o recrearlos cambia la estructura del historial.

Entiende el modelo de ramas antes de reescribirlos.


34. Comprueba el estado actual del rebase

git status

Git informará de:

  • el rebase en curso
  • el commit que se está reaplicando
  • los conflictos
  • los comandos completados/pendientes

Usa git status antes de adivinar qué hacer a continuación.


35. Edita la lista de tareas pendiente del rebase

Durante un rebase interactivo:

git rebase --edit-todo

Úsalo para modificar las acciones siguientes.

No edites a mano los archivos internos del rebase en .git, salvo que entiendas el funcionamiento interno de Git.


36. Recupérate de un rebase accidental con el reflog

git reflog

Busca la punta de la rama anterior al rebase.

Inspecciona:

git show <old-commit>

Crea una rama de recuperación:

git switch -c recovery-before-rebase <old-commit>

El reflog es una de las formas más seguras de recuperar el historial local después de reescribirlo.


37. Crea una rama de respaldo antes del rebase

Antes de una reescritura complicada:

git branch backup-before-rebase

Después, haz el rebase.

Si algo sale mal:

git switch backup-before-rebase

Es un seguro barato.


38. Compara antes y después del rebase

Antes del rebase, guarda la punta anterior:

git branch backup-before-rebase

Después, compara:

git diff backup-before-rebase...HEAD

En una limpieza de historial pura, el contenido final de los archivos normalmente debería seguir siendo equivalente.


39. Verifica el contenido de la funcionalidad después del rebase

git diff origin/main...HEAD

Esto debería seguir representando el cambio previsto de la funcionalidad.

Inspecciona también:

git log --oneline origin/main..HEAD

Asegúrate de que ningún commit de la funcionalidad haya desaparecido de forma inesperada.


40. Ejecuta las pruebas después de resolver los conflictos

El rebase puede producir código que se puede combinar sintácticamente, pero que es lógicamente incorrecto.

Después de resolver los conflictos:

build
pruebas
lint
comprobación de tipos

según corresponda al proyecto.

No tomes un rebase sin conflictos como prueba de que el resultado es correcto.


41. Haz rebase sobre la versión más reciente de main remota sin cambiar de rama

Flujo conciso típico:

git fetch origin
git rebase origin/main

Suele ser la forma más limpia de actualizar a diario una rama de funcionalidad.


42. Configura deliberadamente el comportamiento de pull

Git se puede configurar para que git pull use merge, rebase o solo avance rápido (fast-forward).

Ejemplos:

git config pull.rebase true

o:

git config pull.ff only

No cambies el comportamiento global salvo que entiendas el flujo de trabajo del equipo.

Los comandos explícitos suelen ser más claros en entornos de ingeniería de producción.


43. Haz rebase con autostash cuando corresponda

git rebase --autostash origin/main

Git guarda temporalmente los cambios locales con stash y los vuelve a aplicar después del rebase.

Es cómodo, pero aun así puede generar conflictos al restaurar el trabajo guardado.

Un árbol de trabajo limpio sigue siendo más fácil de razonar.


44. Evita hacer rebase con archivos generados o de entorno sin commit

Si los archivos locales generados o de configuración difieren según el entorno, resuélvelo antes del rebase.

No dejes que los archivos sin seguimiento o generados compliquen innecesariamente las operaciones sobre el historial.


45. Reaplica solo los commits que pertenecen a la funcionalidad

Si:

git log origin/main..HEAD

muestra commits no relacionados, investiga la base de la rama antes del rebase.

Puede que necesites:

git rebase --onto

en lugar de un rebase normal.


46. No hagas rebase solo para que el historial «parezca limpio»

La limpieza del historial debería mejorar:

  • la facilidad de revisión
  • la facilidad de revert
  • la agrupación lógica
  • la comprensión

No reescribas historial compartido estable por motivos estéticos.


47. Entiende que los identificadores de commit cambian

Después del rebase:

commit anterior:
a1b2c3d

commit tras el rebase:
e4f5a6b

El contenido puede ser similar, pero el objeto commit es distinto porque su padre/historial cambió.

Por eso las ramas remotas suelen requerir --force-with-lease después de un rebase.


48. El rebase puede reaplicar conflictos varias veces

Si varios commits tocan la misma zona, pueden aparecer conflictos similares de forma repetida mientras se reaplica cada commit.

Respuestas posibles:

  • resolver cada commit fielmente
  • combinar primero los commits relacionados cuando corresponda
  • cancelar y usar merge si la reescritura no compensa la complejidad

49. Usa rerere solo si tu equipo lo entiende

Git puede recordar resoluciones de conflictos con:

git config rerere.enabled true

Esto puede ayudar cuando el mismo conflicto se repite.

Es útil en flujos de trabajo avanzados, pero la reutilización automática de una resolución anterior debe revisarse igualmente.


50. Usa merge cuando el riesgo del rebase supere el beneficio

Prefiere merge cuando:

  • la rama está compartida
  • los identificadores de commit ya se referencian externamente
  • importa conservar la topología
  • reaplicar los conflictos sería innecesariamente complejo
  • la política del equipo prohíbe reescribir

El rebase es una herramienta, no una obligación.

Qué significa el resultado

Comando Qué hace ¿Reescribe el historial?
git rebase origin/main Reaplica los commits de la rama actual sobre la versión más reciente de main Sí
git rebase -i Reescribe de forma interactiva la secuencia de commits locales Sí
git rebase --continue Continúa tras un conflicto o una edición Continúa la reescritura
git rebase --skip Descarta el commit que se está reaplicando Sí
git rebase --abort Restaura el estado de la rama anterior al rebase No se conserva ninguna reescritura final
git rebase --onto Mueve el rango de commits seleccionado a una nueva base Sí
git rebase --autostash Guarda temporalmente el trabajo local con stash mientras dura el rebase Sí
git push --force-with-lease Actualiza de forma relativamente segura el historial remoto reescrito de la funcionalidad Se reescribe el historial remoto

La distinción principal es:

merge
→ combina historiales existentes

rebase
→ reconstruye los commits sobre una nueva base

Qué revisar

El push se rechaza tras un rebase correcto

Es lo esperado si la versión anterior de la rama ya existe en el remoto.

Si está permitido reescribir la rama:

git push --force-with-lease

No uses --force a secas de forma predeterminada.

El rebase incluye commits inesperados

Detente e inspecciona:

git log origin/main..HEAD
git merge-base origin/main HEAD

Puede que la rama tenga la base equivocada.

El mismo conflicto aparece una y otra vez

Varios commits reaplicados modifican la misma zona.

Plantéate si:

  • deberías combinar los commits
  • un merge es más sencillo
  • la divergencia de la rama se ha vuelto demasiado grande

El rebase terminó, pero el diff de la funcionalidad cambió

Compara:

git diff backup-before-rebase...HEAD

Los cambios de contenido inesperados indican que probablemente la resolución de conflictos alteró el comportamiento.

Desapareció un commit

Comprueba si:

  • se omitió (skip)
  • se eliminó (drop)
  • se absorbió como un parche ya aplicado
  • se omitió por error durante el rebase interactivo

Usa git reflog para recuperar la punta anterior de la rama.

Un compañero dice que su rama se rompió después de tu push forzado

Probablemente reescribiste commits compartidos.

Deja de reescribir y coordina la recuperación con el reflog o con identificadores de commit remotos conocidos.

Notas de producción

El rebase es más seguro antes de compartir

El mejor momento para limpiar el historial de una funcionalidad es antes de que otros desarrolladores dependan de esos identificadores de commit.

Force-with-lease debe seguir siendo intencionado

Es una comprobación de seguridad, no un permiso para reescribir cualquier rama compartida.

CI/CD hace referencia a identificadores de commit

Un rebase cambia los SHA de los commits.

Eso puede afectar a:

  • referencias de build
  • enlaces de despliegue
  • comentarios de revisión de código
  • registros de incidentes

No reescribas el historial a la ligera cuando los flujos de despliegue o de release ya hacen referencia a él.

La resolución de conflictos puede cambiar el comportamiento

Git solo conoce el historial textual.

No sabe si el resultado combinado conserva la semántica de la aplicación.

Ejecuta las pruebas después de un rebase con muchos conflictos.

El rebase interactivo sirve para diseñar el historial

Úsalo para que los commits sean:

  • específicos
  • ordenados lógicamente
  • fáciles de revisar
  • reversibles

No reduzcas automáticamente cada funcionalidad a un único commit gigante.

Las ramas de respaldo y el reflog hacen más segura la reescritura local

Antes de reescrituras complejas:

git branch backup-before-rebase

y ten presente que:

git reflog

a menudo puede recuperar la punta anterior.

Errores comunes

1. Hacer rebase sin hacer fetch antes

Puedes hacer rebase sobre un estado remoto desactualizado.

2. Hacer rebase de ramas compartidas

Esto cambia identificadores de commit de los que otros desarrolladores pueden depender.

3. Hacer push forzado con --force

Usa --force-with-lease cuando la reescritura sea realmente necesaria.

4. Usar --skip solo para sortear un conflicto

Esto elimina el commit que se está reaplicando.

5. Tratar la resolución de conflictos como algo mecánico

El resultado correcto puede combinar ambas versiones.

6. Usar el rebase interactivo en historial ya compartido sin coordinación

Cada commit editado, combinado o reordenado recibe una identidad nueva.

7. Reordenar mal commits dependientes

Los commits posteriores pueden depender de cambios anteriores.

Mantén intactas las dependencias lógicas.

8. Combinar commits no relacionados

Esto perjudica la facilidad de revisión y los reverts futuros.

9. Suponer que el rebase conserva automáticamente el contenido exacto

La resolución de conflictos puede alterar el comportamiento final.

Compara y prueba después.

10. Usar rebase cuando merge es más sencillo y seguro

Un grafo lineal no justifica un riesgo operativo innecesario.

Siguiente paso

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

  • La rama de funcionalidad privada está por detrás de main → haz fetch y luego rebase sobre origin/main.
  • La rama ya está muy compartida → prefiere merge, salvo que la reescritura esté coordinada.
  • Necesitas limpiar commits locales → usa el rebase interactivo.
  • Necesitas combinar commits fixup → usa --fixup + --autosquash.
  • La rama partió de la base equivocada → inspecciona el rango de commits y luego usa rebase --onto.
  • Aparece un conflicto → resuélvelo, añádelo al área de preparación y ejecuta rebase --continue.
  • La dirección o la base del rebase es incorrecta → git rebase --abort.
  • El rebase salió bien, pero el remoto rechaza el push → usa --force-with-lease solo si se espera reescribir el remoto.
  • Crees que ha desaparecido trabajo → inspecciona git reflog.
  • Los conflictos son demasiado complejos para reaplicarlos con seguridad → cancela y considera hacer merge.

← Todas las guías rápidas