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