Explorar guías rápidas · Git

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

Deshacer cambios de forma segura

Deshaz cambios en Git de forma segura eligiendo el comando adecuado para cambios sin preparar, cambios preparados, commits locales o historial compartido, sin destruir trabajo por accidente.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. Inspeccionar antes de deshacer
  5. Deshacer los cambios sin preparar de un archivo rastreado
  6. Deshacer todos los cambios sin preparar de archivos rastreados
  7. Restaurar un archivo desde HEAD
  8. Restaurar un archivo desde un commit anterior
  9. Restaurar un archivo desde otra rama
  10. Quitar un archivo del área de preparación conservando sus ediciones
  11. Quitar todo del área de preparación conservando todas las ediciones
  12. Quitar del área de preparación fragmentos (hunks) concretos
  13. Corregir el mensaje del último commit local
  14. Añadir un archivo olvidado al último commit local
  15. Quitar el último commit local manteniendo los cambios preparados
  16. Quitar el último commit local manteniendo los cambios sin preparar
  17. Entender los modos de reset
  18. Evitar git reset --hard para la limpieza rutinaria
  19. Deshacer un commit compartido con git revert
  20. Hacer revert del último commit compartido
  21. Hacer revert de un rango contiguo en un único commit nuevo
  22. Abortar un revert con conflictos
  23. Continuar un revert con conflictos
  24. Hacer revert de un commit de merge con cuidado
  25. Descartar los cambios preparados y sin preparar de un archivo rastreado
  26. Recuperar un commit eliminado por un reset accidental
  27. Recuperar una rama local eliminada
  28. Recuperar tras un rebase o un amend accidental
  29. Recuperar un archivo sin mover la rama
  30. Deshacer solo una parte de un archivo sin preparar
  31. Inspeccionar un commit antes de deshacerlo
  32. Comparar lo que desaparecería antes de mover una rama hacia atrás
  33. Hacer reset a un commit local concreto conservando las ediciones
  34. Hacer hard reset a una rama remota solo cuando el trabajo local sea desechable
  35. Investigar un push rechazado en lugar de borrar el trabajo local
  36. Deshacer la eliminación de un archivo rastreado antes del commit
  37. Previsualizar la limpieza de archivos sin rastrear
  38. Eliminar archivos sin rastrear solo de forma intencionada
  39. Tener especial cuidado con los archivos ignorados
  40. Usar stash cuando no tengas claro si el trabajo debe descartarse
  41. Quitar un commit del historial privado
  42. Deshacer un merge accidental antes de su commit
  43. Deshacer un merge local completado
  44. Deshacer un cherry-pick en curso
  45. Deshacer un cherry-pick compartido ya completado
  46. Preferir revert para los commits de rollback en producción
  47. Verificar después de deshacer
  48. Qué significa el resultado
  49. Qué revisar
  50. No sabes si un cambio está preparado
  51. Un reset eliminó un commit que todavía necesitas
  52. El revert produjo conflictos
  53. git restore no eliminó un archivo sin rastrear
  54. El push se rechaza después de un reset local
  55. Deshacer un commit rompe código posterior
  56. Notas de producción
  57. El historial compartido normalmente debe deshacerse con revert
  58. Reset es sobre todo una herramienta para el historial local
  59. El reflog es local
  60. Puede que los archivos sin rastrear no tengan forma de recuperarse con Git
  61. Las ramas de respaldo son baratas
  62. Un revert correcto puede seguir rompiendo la aplicación
  63. Errores comunes
  64. 1. Empezar con git reset --hard
  65. 2. Usar reset en historial compartido
  66. 3. Usar revert cuando querías reescribir historial local privado
  67. 4. Suponer que git restore puede recuperar archivos sin rastrear
  68. 5. Ejecutar git clean -fd sin previsualizar
  69. 6. Hacer amend de un commit compartido a la ligera
  70. 7. Hacer revert de un merge sin entender -m
  71. 8. Hacer force push después de un reset sin comprobar los cambios remotos
  72. 9. Eliminar una rama porque el commit está «probablemente en otro sitio»
  73. 10. Saltarse la verificación después de deshacer
  74. Siguiente paso
  75. Para profundizar

Problema

Modificaste el archivo equivocado, preparaste demasiado, hiciste commit de algo por error o necesitas deshacer un cambio que ya está compartido.

Git tiene varios comandos que suenan parecidos:

restore
reset
revert
checkout
reflog

pero afectan a partes distintas del estado de Git.

El riesgo es usar un comando destructivo antes de identificar dónde está el cambio no deseado:

  • solo en el árbol de trabajo
  • en el área de preparación (staging area, también llamada índice)
  • en un commit local
  • en el historial publicado/compartido

El objetivo es deshacer el alcance más pequeño posible sin perder la posibilidad de recuperación.

Respuesta rápida

Usa este flujo de decisión:

Edición de archivo sin preparar
→ git restore <file>

Preparado por error
→ git restore --staged <file>

Último commit local incorrecto, mantener cambios preparados
→ git reset --soft HEAD~1

Último commit local incorrecto, mantener cambios sin preparar
→ git reset HEAD~1

Último commit local necesita un pequeño ajuste
→ git commit --amend

Commit compartido/con push que hay que deshacer
→ git revert <commit>

Crees que se perdió un commit local
→ git reflog

Antes de deshacer nada:

git status
git diff
git diff --cached
git log --oneline --decorate -10

No empieces con:

git reset --hard

salvo que quieras descartar intencionadamente los cambios locales rastreados.

Código / comandos

Inspeccionar antes de deshacer

git status
git diff
git diff --cached
git log --oneline --decorate -10

Estos comandos son de bajo riesgo y te indican si el cambio no deseado está en el árbol de trabajo, en el índice o en el historial de commits.

Deshacer los cambios sin preparar de un archivo rastreado

git restore src/app.py

Esto descarta las ediciones sin preparar de ese archivo.

Compruébalo primero:

git diff src/app.py

Deshacer todos los cambios sin preparar de archivos rastreados

git restore .

Esto puede descartar muchas ediciones locales. Revisa primero git status y git diff.

Restaurar un archivo desde HEAD

git restore \
  --source=HEAD \
  -- src/app.py

Restaurar un archivo desde un commit anterior

git restore \
  --source=HEAD~1 \
  -- src/app.py

Esto solo modifica el archivo del árbol de trabajo. Revísalo y haz commit por separado si estás restaurando la versión anterior a propósito.

Restaurar un archivo desde otra rama

git restore \
  --source=origin/main \
  -- src/app.py

Úsalo cuando un archivo deba coincidir con otra rama sin mover tu rama actual.

Quitar un archivo del área de preparación conservando sus ediciones

git restore --staged src/app.py

El archivo sigue modificado en el árbol de trabajo.

Quitar todo del área de preparación conservando todas las ediciones

git restore --staged .

Útil antes de reorganizar un cambio preparado grande en commits más pequeños.

Quitar del área de preparación fragmentos (hunks) concretos

git reset -p

Luego vuelve a preparar solo las partes correctas:

git add -p
git diff --cached

Corregir el mensaje del último commit local

git commit --amend

Esto crea un nuevo ID de commit. Úsalo sin problema mientras el commit no esté compartido.

Añadir un archivo olvidado al último commit local

git add src/config.py
git commit --amend --no-edit

No hagas amend a la ligera de commits de los que otras personas ya dependen.

Quitar el último commit local manteniendo los cambios preparados

git reset --soft HEAD~1

Resultado:

commit eliminado del historial de la rama local
los cambios siguen preparados

Quitar el último commit local manteniendo los cambios sin preparar

git reset HEAD~1

El modo predeterminado es --mixed.

Resultado:

commit eliminado
los cambios siguen en el árbol de trabajo
área de preparación restablecida

Entender los modos de reset

--soft
→ mueve HEAD/la rama
→ conserva el índice
→ conserva el árbol de trabajo

--mixed
→ mueve HEAD/la rama
→ restablece el índice
→ conserva el árbol de trabajo

--hard
→ mueve HEAD/la rama
→ restablece el índice
→ restablece el árbol de trabajo

--hard es la opción destructiva.

Evitar git reset --hard para la limpieza rutinaria

git reset --hard HEAD

Esto descarta los cambios rastreados, tanto preparados como sin preparar.

Antes de usarlo:

git status
git diff
git diff --cached

Si el commit actual puede importar, crea primero una rama de respaldo:

git branch backup-before-reset

Deshacer un commit compartido con git revert

git revert <commit>

Ejemplo:

git revert a1b2c3d

Esto crea un nuevo commit que invierte el commit seleccionado.

Úsalo para el historial compartido, porque los ID de commit existentes quedan intactos.

Hacer revert del último commit compartido

git revert HEAD

Hacer revert de un rango contiguo en un único commit nuevo

git revert --no-commit <oldest>^..<newest>

Revisa:

git status
git diff --cached

Luego haz commit:

git commit -m "Revert problematic release changes"

Abortar un revert con conflictos

git revert --abort

Continuar un revert con conflictos

Resuelve los archivos y después:

git add path/to/file
git revert --continue

Hacer revert de un commit de merge con cuidado

git revert -m 1 <merge-commit>

-m selecciona el padre principal (mainline). No lo adivines.

Inspecciona primero el merge:

git show --no-patch --pretty=%P <merge-commit>

Un padre equivocado puede revertir el lado equivocado del merge.

Descartar los cambios preparados y sin preparar de un archivo rastreado

git restore \
  --source=HEAD \
  --staged \
  --worktree \
  -- src/app.py

Esto es destructivo para ese archivo.

Recuperar un commit eliminado por un reset accidental

git reflog

Ejemplo:

e4f5a6b HEAD@{0}: reset: moving to HEAD~1
a1b2c3d HEAD@{1}: commit: Add report engine

Inspecciona:

git show a1b2c3d

Recupera de forma segura:

git switch -c recovery a1b2c3d

Recuperar una rama local eliminada

git reflog
git switch -c recovered-feature <commit>

Eliminar una rama normalmente elimina el nombre de la rama, no el objeto commit de inmediato.

Recuperar tras un rebase o un amend accidental

git reflog

Busca la punta anterior de la rama, inspecciónala y crea una rama de recuperación temporal:

git switch -c before-rewrite <old-commit>

Recuperar un archivo sin mover la rama

git restore \
  --source=<commit> \
  -- path/to/file

Prefiere esto a hacer reset de toda una rama solo para recuperar un archivo.

Deshacer solo una parte de un archivo sin preparar

git restore -p src/app.py

Git te muestra los fragmentos (hunks) y te deja elegir qué descartar.

Inspeccionar un commit antes de deshacerlo

git show <commit>

Solo el resumen:

git show --stat <commit>

Comparar lo que desaparecería antes de mover una rama hacia atrás

git diff <commit>..HEAD

Hacer reset a un commit local concreto conservando las ediciones

Mantener preparadas:

git reset --soft <commit>

Mantener sin preparar:

git reset <commit>

Úsalo solo cuando reescribir el historial sea aceptable.

Hacer hard reset a una rama remota solo cuando el trabajo local sea desechable

git fetch origin
git reset --hard origin/main

Antes de hacerlo:

git status
git log --oneline origin/main..HEAD
git branch backup-before-hard-reset

No lo hagas solo porque se rechazó un push.

Investigar un push rechazado en lugar de borrar el trabajo local

git fetch origin
git log \
  --oneline \
  --graph \
  --decorate \
  HEAD \
  origin/<branch>

Entiende primero la divergencia.

Deshacer la eliminación de un archivo rastreado antes del commit

Si no está preparada:

git restore path/to/file

Si la eliminación está preparada:

git restore --staged path/to/file
git restore path/to/file

Previsualizar la limpieza de archivos sin rastrear

git restore no puede recuperar ni eliminar archivos que Git nunca rastreó.

Previsualiza:

git clean -n

Incluir directorios:

git clean -nd

Eliminar archivos sin rastrear solo de forma intencionada

git clean -f

Incluir directorios sin rastrear:

git clean -fd

Estos comandos son destructivos.

Tener especial cuidado con los archivos ignorados

Previsualiza:

git clean -nx

git clean -x incluye los archivos ignorados y puede eliminar archivos de entorno, artefactos generados, cachés y configuración local.

Usar stash cuando no tengas claro si el trabajo debe descartarse

git stash push -u -m "Safety copy before cleanup"

Luego inspecciónalo más tarde:

git stash list
git stash show -p stash@{0}

Quitar un commit del historial privado

Para historial local/no compartido:

git rebase -i HEAD~5

Cambia:

pick a1b2c3d Bad commit

por:

drop a1b2c3d Bad commit

Esto reescribe los ID de los commits afectados.

Deshacer un merge accidental antes de su commit

git merge --abort

Deshacer un merge local completado

Si no está publicado, conserva primero un puntero de recuperación:

git branch backup-before-reset
git reset --hard HEAD~1

Si el merge ya está compartido, haz revert del merge en su lugar.

Deshacer un cherry-pick en curso

git cherry-pick --abort

Deshacer un cherry-pick compartido ya completado

git revert HEAD

Preferir revert para los commits de rollback en producción

Para un cambio compartido y desplegado:

git revert <commit>
git push

Así se conserva un rollback auditable.

Verificar después de deshacer

Vuelve a ejecutar las comprobaciones pertinentes:

git status
git diff
git diff --cached
git log --oneline --decorate -10

Que un comando termine correctamente no demuestra que hayas deshecho lo que pretendías.

Qué significa el resultado

Situación Comando más seguro ¿Conserva las ediciones? ¿Reescribe el historial?
Edición de archivo sin preparar git restore <file> No para las ediciones seleccionadas No
Preparado por error git restore --staged <file> Sí No
Último commit local, mantener preparado git reset --soft HEAD~1 Sí Sí
Último commit local, mantener sin preparar git reset HEAD~1 Sí Sí
Último commit local necesita un pequeño ajuste git commit --amend Sí Sí
Commit compartido que hay que deshacer git revert <commit> Sí No
Commit local perdido git reflog Ayuda para recuperar No
Eliminar archivos sin rastrear git clean No No

La distinción importante es:

restore
→ árbol de trabajo / índice

reset
→ rama + índice + posiblemente árbol de trabajo

revert
→ nuevo commit que invierte historial compartido existente

Qué revisar

No sabes si un cambio está preparado

Ejecuta:

git status
git diff
git diff --cached

No lo adivines.

Un reset eliminó un commit que todavía necesitas

Ejecuta:

git reflog

Es posible que el commit anterior siga siendo recuperable.

El revert produjo conflictos

El repositorio cambió desde el commit original.

Resuelve con cuidado el cambio inverso que buscas y luego continúa el revert.

git restore no eliminó un archivo sin rastrear

Es lo esperado.

Usa:

git clean -n

para previsualizar la limpieza de archivos sin rastrear.

El push se rechaza después de un reset local

Reescribiste el historial de la rama.

No hagas force push hasta confirmar si la rama remota está compartida.

Deshacer un commit rompe código posterior

Puede que commits posteriores dependan de él.

Inspecciona la cadena de dependencias antes de hacer revert de más historial.

Notas de producción

El historial compartido normalmente debe deshacerse con revert

Así se conservan:

  • la pista de auditoría
  • los ID de commit
  • las referencias de CI/CD
  • el historial de los colaboradores

Reset es sobre todo una herramienta para el historial local

Úsalo para commits que no estén ampliamente compartidos.

El reflog es local

git reflog registra los movimientos de las referencias locales.

No es un registro de auditoría remoto/global, y la recuperación depende de la retención local del reflog y de los objetos.

Puede que los archivos sin rastrear no tengan forma de recuperarse con Git

Si un archivo sin rastrear nunca pasó por un commit ni por un stash y se elimina con git clean, Git normalmente no puede restaurarlo.

Las ramas de respaldo son baratas

Antes de operaciones arriesgadas:

git branch backup-before-change

Esto puede hacer que la recuperación sea trivial.

Un revert correcto puede seguir rompiendo la aplicación

El código de rollback puede entrar en conflicto con:

  • migraciones de base de datos
  • contratos de API
  • el estado del despliegue
  • feature flags
  • commits posteriores dependientes

Ejecuta las pruebas y valida el plan de release/rollback.

Errores comunes

1. Empezar con git reset --hard

Puede destruir trabajo local rastreado sin necesidad.

2. Usar reset en historial compartido

Esto reescribe el historial de la rama y puede afectar a los colaboradores.

3. Usar revert cuando querías reescribir historial local privado

Revert conserva el commit original y añade un commit inverso.

Para una limpieza no publicada, reset/rebase puede ser más limpio.

4. Suponer que git restore puede recuperar archivos sin rastrear

No puede restaurar contenido que Git nunca rastreó.

5. Ejecutar git clean -fd sin previsualizar

Los archivos sin rastrear pueden eliminarse de forma permanente.

6. Hacer amend de un commit compartido a la ligera

El ID del commit cambia.

7. Hacer revert de un merge sin entender -m

Puedes invertir el lado equivocado del merge.

8. Hacer force push después de un reset sin comprobar los cambios remotos

Puedes sobrescribir los commits de tus compañeros.

9. Eliminar una rama porque el commit está «probablemente en otro sitio»

Compruébalo primero.

10. Saltarse la verificación después de deshacer

Puede que Git haya hecho exactamente lo que pediste, pero no lo que pretendías.

Siguiente paso

Usa el estado actual para elegir la forma más acotada y segura de deshacer.

  • Una edición sin preparar debe desaparecer → git restore <file>.
  • Un archivo se preparó por error → git restore --staged <file>.
  • Necesitas dividir el trabajo preparado → prepara/quita del área de preparación por fragmentos (patch).
  • El último commit local debe rehacerse → usa un reset soft o mixed.
  • El último commit local necesita un pequeño ajuste → haz amend antes de compartirlo.
  • Un commit publicado debe invertirse → git revert.
  • Un merge compartido debe deshacerse → inspecciona los padres del merge y luego haz revert del merge.
  • Crees que se perdió trabajo → inspecciona git reflog.
  • Hay que limpiar archivos sin rastrear → previsualiza con git clean -n.
  • No tienes claro si el trabajo importa → crea una rama de respaldo o un stash antes de cualquier comando destructivo.

← Todas las guías rápidas