Explorar guías rápidas · Git

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

Git stash: guardar cambios temporalmente

Usa git stash de forma segura para apartar trabajo sin terminar, cambiar de contexto, inspeccionar y restaurar cambios guardados, gestionar archivos sin seguimiento y recuperarte cuando aplicar un stash genera conflictos.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Revisa primero el árbol de trabajo
  5. 2. Guarda los cambios con seguimiento
  6. 3. Incluye los archivos sin seguimiento
  7. 4. Entiende lo que -u no incluye
  8. 5. Pon un mensaje útil a cada stash
  9. 6. Lista los stashes
  10. 7. Muestra el resumen de un stash
  11. 8. Inspecciona el patch completo de un stash
  12. 9. Aplica un stash sin borrarlo
  13. 10. Aplica el stash más reciente
  14. 11. Haz pop del stash más reciente
  15. 12. Haz pop de un stash concreto
  16. 13. Prefiere apply para el trabajo valioso
  17. 14. Elimina un stash
  18. 15. Borra todos los stashes solo de forma intencionada
  19. 16. Guarda solo archivos seleccionados
  20. 17. Guarda de forma interactiva, fragmento a fragmento
  21. 18. Mantén en su sitio los cambios preparados
  22. 19. Guarda solo los cambios preparados
  23. 20. Consulta la versión actual de Git
  24. 21. Crea una rama directamente desde un stash
  25. 22. Usa stash branch cuando el contexto ha cambiado mucho
  26. 23. Haz stash antes de cambiar de rama
  27. 24. Haz stash antes de hacer rebase
  28. 25. Usa el autostash del rebase cuando sea apropiado
  29. 26. Haz stash antes de hacer pull cuando los cambios locales bloquean la actualización
  30. 27. Revisa el estado después de aplicar
  31. 28. Gestiona los conflictos de stash apply
  32. 29. Entiende el comportamiento de apply ante conflictos
  33. 30. Entiende el comportamiento de pop ante conflictos
  34. 31. Comprueba si hay conflictos después de un pop
  35. 32. Restaura el estado preparado desde un stash
  36. 33. Haz pop restaurando el índice
  37. 34. Inspecciona el stash como commits
  38. 35. Compara un stash con el trabajo actual
  39. 36. Compara el contenido del stash con su base original
  40. 37. Guarda con cuidado un archivo parcialmente preparado
  41. 38. Usa el modo patch para delimitar con precisión el stash
  42. 39. Usa pathspecs para no guardar archivos no relacionados
  43. 40. No uses el stash como almacenamiento del proyecto a largo plazo
  44. 41. Convierte el trabajo importante de un stash en una rama
  45. 42. Usa un commit WIP cuando la colaboración importa
  46. 43. Recuerda que los stashes son locales por defecto
  47. 44. Usa el stash para cambios de contexto breves
  48. 45. Recupera un stash eliminado recientemente con el reflog y la inspección de objetos
  49. 46. No ejecutes una recolección de basura agresiva durante la recuperación
  50. 47. Comprueba que el estado queda limpio después del stash
  51. 48. El stash no sustituye a .gitignore
  52. 49. El stash no resuelve problemas de organización de ramas
  53. 50. Verifica antes de eliminar
  54. Qué significa el resultado
  55. Qué revisar
  56. Los archivos nuevos desaparecieron después del stash
  57. El stash se aplica con conflictos
  58. pop no eliminó el stash
  59. La división entre preparado y no preparado cambió después de aplicar
  60. Tienes muchos stashes antiguos
  61. Notas de producción
  62. Los stashes son estado local
  63. apply es más seguro que pop para el trabajo importante
  64. Los archivos sin seguimiento e ignorados requieren opciones explícitas
  65. Los conflictos de stash son normales cuando las ramas divergen
  66. Los stashes pueden contener archivos sensibles
  67. El trabajo de larga duración pertenece a una rama
  68. Errores comunes
  69. 1. Suponer que los archivos sin seguimiento se guardan automáticamente
  70. 2. Usar pop antes de inspeccionar un stash antiguo
  71. 3. Borrar todos los stashes a la ligera
  72. 4. Tratar el stash como una copia de seguridad duradera
  73. 5. Guardar archivos ignorados con -a sin revisarlos
  74. 6. Suponer que el estado preparado siempre se restaura exactamente
  75. 7. Eliminar un stash antes de probar el trabajo restaurado
  76. 8. Dejar los stashes sin nombre
  77. 9. Aplicar un stash muy antiguo sobre una rama que ha cambiado mucho
  78. 10. Usar el stash para gestionar varias tareas de larga duración
  79. Siguiente paso
  80. Para profundizar

Problema

Tienes trabajo local sin terminar, pero necesitas:

  • cambiar de rama
  • hacer pull o rebase
  • probar otro cambio
  • atender una corrección urgente
  • limpiar temporalmente el árbol de trabajo
  • conservar cambios sin crear un commit permanente

git stash puede ayudarte, pero usarlo sin cuidado causa problemas:

  • olvidar qué contiene un stash
  • perder la pista cuando hay varios stashes
  • suponer que los archivos sin seguimiento se incluyen automáticamente
  • usar pop antes de inspeccionar
  • crear conflictos al restaurar
  • tratar el stash como almacenamiento a largo plazo
  • borrar stashes por accidente

El objetivo es usar el stash como una herramienta de seguridad temporal e inspeccionable, no como sustituto de las ramas o los commits.

Respuesta rápida

Guardar los cambios con seguimiento:

git stash push -m "WIP report engine"

Incluir los archivos sin seguimiento:

git stash push -u -m "WIP report engine"

Listar los stashes:

git stash list

Inspeccionar antes de restaurar:

git stash show -p stash@{0}

Aplicar sin borrar:

git stash apply stash@{0}

Eliminar solo después de confirmar que el trabajo se ha restaurado:

git stash drop stash@{0}

Usa pop solo cuando te sientas seguro aplicando y eliminando el stash en un único paso:

git stash pop

Código / comandos

1. Revisa primero el árbol de trabajo

git status

Debes saber qué se va a guardar antes de ejecutar el comando.

Según las opciones, un stash puede incluir distintos conjuntos de cambios.


2. Guarda los cambios con seguimiento

git stash push -m "WIP report engine"

De forma predeterminada, esto guarda los cambios con seguimiento, tanto los preparados (en el área de preparación o staging area) como los no preparados.

El árbol de trabajo vuelve hacia el estado de HEAD.


3. Incluye los archivos sin seguimiento

git stash push -u -m "WIP report engine"

-u / --include-untracked incluye los archivos sin seguimiento.

Úsalo cuando haya archivos nuevos que formen parte del trabajo sin terminar.


4. Entiende lo que -u no incluye

-u no incluye los archivos ignorados.

Si de verdad necesitas también los archivos ignorados:

git stash push -a -m "WIP including ignored files"

-a / --all incluye los archivos ignorados.

Úsalo con cuidado, porque los archivos ignorados suelen incluir:

  • artefactos de compilación
  • cachés
  • archivos de entorno locales
  • datos generados

5. Pon un mensaje útil a cada stash

Es preferible:

git stash push -m "WIP Fabric pipeline retry changes"

a:

git stash

Los mensajes descriptivos importan en cuanto existen varios stashes.


6. Lista los stashes

git stash list

Ejemplo:

stash@{0}: On feature/report-engine: WIP retry logic
stash@{1}: On main: WIP README update

El stash más reciente suele ser stash@{0}.


7. Muestra el resumen de un stash

git stash show stash@{0}

Esto muestra un resumen al estilo diffstat.


8. Inspecciona el patch completo de un stash

git stash show -p stash@{0}

Hazlo antes de restaurar un stash antiguo o que no conoces bien.


9. Aplica un stash sin borrarlo

git stash apply stash@{0}

Úsalo cuando quieras conservar el stash hasta verificar el trabajo restaurado.

Es más seguro que pop para cambios importantes.


10. Aplica el stash más reciente

git stash apply

Equivale a aplicar el stash más reciente.

Cuando hay varios stashes, indicar el stash exacto es más claro.


11. Haz pop del stash más reciente

git stash pop

Esto aplica el stash más reciente y, si la aplicación se completa sin problemas, elimina esa entrada de stash.

Úsalo cuando tengas claro que la restauración es sencilla.


12. Haz pop de un stash concreto

git stash pop stash@{1}

Útil cuando el stash que buscas no es el más reciente.


13. Prefiere apply para el trabajo valioso

Flujo de recuperación más seguro:

git stash apply stash@{0}
git status
git diff

Después de verificar:

git stash drop stash@{0}

Así conservas una copia de seguridad hasta confirmar que el trabajo se ha restaurado correctamente.


14. Elimina un stash

git stash drop stash@{0}

Esto borra esa referencia de stash.

Inspecciónalo antes si tienes cualquier duda.


15. Borra todos los stashes solo de forma intencionada

git stash clear

Esto elimina todas las entradas de stash.

No lo uses como limpieza rutinaria.

No hay la confirmación habitual entrada por entrada.


16. Guarda solo archivos seleccionados

git stash push \
  -m "WIP API changes" \
  -- src/api.py src/config.py

Así los cambios no relacionados del árbol de trabajo se quedan donde están.

Usa pathspecs cuando solo una parte del trabajo tenga que apartarse.


17. Guarda de forma interactiva, fragmento a fragmento

git stash push -p

Git te pregunta por cada fragmento (hunk).

Úsalo cuando un mismo archivo contiene:

  • trabajo que quieres guardar en el stash
  • trabajo que quieres mantener activo

18. Mantén en su sitio los cambios preparados

Si tu versión de Git lo admite:

git stash push --keep-index

Esto guarda los demás cambios y deja los cambios preparados en el índice.

Útil cuando quieres probar de forma independiente el commit que tienes preparado.


19. Guarda solo los cambios preparados

En versiones modernas de Git:

git stash push --staged

Esto guarda el contenido preparado y deja los cambios no preparados en el árbol de trabajo.

Comprueba tu versión de Git si esta opción no está disponible.


20. Consulta la versión actual de Git

git --version

Útil cuando las opciones de stash varían entre instalaciones de Git más antiguas.


21. Crea una rama directamente desde un stash

git stash branch recovery-work stash@{0}

Esto:

  1. crea una rama nueva a partir del commit en el que se creó originalmente el stash
  2. aplica el stash
  3. lo elimina si la aplicación se completa correctamente

Úsalo cuando la rama actual ha divergido y aplicar el stash directamente produce conflictos.


22. Usa stash branch cuando el contexto ha cambiado mucho

Situación de ejemplo:

stash creado hace dos semanas
main ha cambiado mucho
la rama de funcionalidad ha cambiado mucho

En lugar de aplicarlo sobre la rama actual:

git stash branch old-wip stash@{2}

Esto suele darle a Git una base más compatible.


23. Haz stash antes de cambiar de rama

git stash push -u -m "WIP before hotfix"
git switch hotfix/production

Después de la corrección urgente:

git switch feature/report-engine
git stash apply stash@{0}

Usa mensajes explícitos para que el stash siga siendo fácil de identificar.


24. Haz stash antes de hacer rebase

git stash push -u -m "WIP before rebase"
git fetch origin
git rebase origin/main
git stash apply stash@{0}

Un árbol de trabajo limpio hace que el rebase sea más fácil de entender.


25. Usa el autostash del rebase cuando sea apropiado

git rebase --autostash origin/main

Git crea automáticamente un stash temporal y lo vuelve a aplicar al final.

Es cómodo, pero aun así pueden producirse conflictos al restaurar el stash temporal.

Un stash manual suele ser más fácil de inspeccionar y controlar.


26. Haz stash antes de hacer pull cuando los cambios locales bloquean la actualización

Si el flujo de trabajo del equipo exige pull/rebase:

git stash push -u -m "WIP before sync"
git pull --ff-only

o:

git fetch origin
git rebase origin/main

Después restaura el stash.

No hagas stash de forma automática sin comprobar si esos cambios deberían ir antes en un commit.


27. Revisa el estado después de aplicar

git status

Luego:

git diff
git diff --cached

No des por hecho que la aplicación del stash ha restaurado exactamente lo que esperabas.


28. Gestiona los conflictos de stash apply

Si la aplicación genera conflictos:

git status

Git marca los archivos en conflicto.

Resuélvelos manualmente y luego:

git add path/to/file

A diferencia del rebase, no existe:

git stash --continue

Resuelves el árbol de trabajo de la forma habitual.


29. Entiende el comportamiento de apply ante conflictos

Si:

git stash apply stash@{0}

genera conflictos, la entrada de stash se conserva.

Es útil, porque el stash original sigue existiendo mientras resuelves el árbol de trabajo.


30. Entiende el comportamiento de pop ante conflictos

Si git stash pop encuentra conflictos, Git suele conservar el stash en lugar de eliminarlo.

Aun así, verifícalo con:

git stash list

No des por hecho que el stash se ha eliminado.


31. Comprueba si hay conflictos después de un pop

git status

Luego:

git stash list

Confirma tanto el estado del árbol de trabajo como si la entrada de stash sigue existiendo.


32. Restaura el estado preparado desde un stash

De forma predeterminada, aplicar un stash restaura los cambios en los archivos, pero puede que no recree exactamente la división entre cambios preparados y no preparados.

Usa:

git stash apply --index stash@{0}

para intentar restaurar también el estado preparado.

Puede fallar si el índice no se puede aplicar limpiamente.


33. Haz pop restaurando el índice

git stash pop --index

Úsalo solo cuando importe restaurar el estado original del área de preparación.

Para trabajo valioso, prefiere primero apply --index.


34. Inspecciona el stash como commits

Internamente, un stash se representa mediante commits de Git.

Puedes inspeccionarlo:

git show stash@{0}

o:

git log -g --oneline refs/stash

Normalmente no necesitas conocer la estructura interna, pero saber que el stash se apoya en objetos de Git ayuda a entender por qué a veces funciona la recuperación basada en el reflog.


35. Compara un stash con el trabajo actual

git diff stash@{0}

Para un archivo concreto:

git diff stash@{0} -- src/app.py

Hazlo antes de aplicar si el código actual ha cambiado mucho.


36. Compara el contenido del stash con su base original

git stash show -p stash@{0}

Suele ser la forma más clara de ver qué introdujo el stash.


37. Guarda con cuidado un archivo parcialmente preparado

Un archivo puede contener:

cambios preparados
+
cambios no preparados

Antes de hacer stash, inspecciona ambos:

git diff --cached
git diff

Luego decide si necesitas:

  • un stash normal
  • --keep-index
  • --staged
  • el modo patch

No des por hecho que el límite entre lo preparado y lo no preparado se comportará como pretendes.


38. Usa el modo patch para delimitar con precisión el stash

git stash push -p -m "Only experimental changes"

Úsalo cuando necesites control a nivel de fragmento.

Revisa cada fragmento con atención.


39. Usa pathspecs para no guardar archivos no relacionados

git stash push \
  -m "WIP backend only" \
  -- src/api src/services

Es útil en repositorios donde se trabaja a la vez en varias tareas no relacionadas.

Mejor aún, plantéate usar ramas o worktrees separados si este patrón es frecuente.


40. No uses el stash como almacenamiento del proyecto a largo plazo

Mal patrón:

stash@{0}  de hace 3 meses
stash@{1}  de hace 4 meses
stash@{2}  "WIP"
stash@{3}  "stuff"

Si el trabajo importa, es preferible:

rama temporal
+
commits normales

Las ramas son más fáciles de:

  • revisar
  • subir con push
  • respaldar
  • compartir
  • recuperar

41. Convierte el trabajo importante de un stash en una rama

git stash branch feature/recovered-work stash@{0}

Después haz commit con normalidad.

Así el estado temporal se convierte en historial duradero.


42. Usa un commit WIP cuando la colaboración importa

En lugar de hacer stash de trabajo importante:

git add -A
git commit -m "WIP: report engine changes"

en una rama de funcionalidad privada puede ser más seguro, porque el trabajo se puede subir al remoto.

Más adelante, limpia el historial con un rebase interactivo si es necesario.

No hagas push de commits WIP a ramas protegidas o compartidas salvo que la política del equipo lo permita.


43. Recuerda que los stashes son locales por defecto

Un stash no se sube automáticamente a GitHub, GitLab, Azure DevOps ni a ningún otro remoto.

Si tu portátil desaparece, un stash que no se ha subido puede desaparecer con él.

El trabajo importante debe convertirse en un commit en una rama.


44. Usa el stash para cambios de contexto breves

Buenos ejemplos:

corrección urgente
comparación rápida de ramas
limpieza temporal para un rebase
probar con un árbol de trabajo limpio

Mal uso:

guardar indefinidamente una semana de funcionalidad sin terminar

45. Recupera un stash eliminado recientemente con el reflog y la inspección de objetos

Empieza con:

git reflog --all

y:

git fsck --no-reflogs --unreachable

La recuperación no está garantizada y se vuelve más difícil después de la recolección de basura (garbage collection).

No dependas de esto como flujo de trabajo normal.

Es mejor prevenir: inspecciona antes de eliminar y usa ramas para el trabajo importante.


46. No ejecutes una recolección de basura agresiva durante la recuperación

Si estás intentando recuperar un stash eliminado, evita los comandos que puedan podar objetos inalcanzables.

Crea una referencia de recuperación en cuanto identifiques el commit correspondiente.


47. Comprueba que el estado queda limpio después del stash

Después de:

git stash push -u -m "WIP"

ejecuta:

git status

Confirma que el árbol de trabajo está realmente lo bastante limpio para la siguiente operación.

Puede que sigan quedando archivos ignorados.


48. El stash no sustituye a .gitignore

Si los archivos generados interfieren una y otra vez en las operaciones con ramas, corrige las reglas de exclusión del repositorio cuando corresponda.

No hagas stash ni limpies repetidamente archivos que nunca deberían estar bajo control de versiones.


49. El stash no resuelve problemas de organización de ramas

Si haces stash constantemente porque llevas varias tareas en paralelo en un mismo directorio de trabajo, plantéate:

  • ramas de funcionalidad separadas
  • git worktree
  • tareas con un alcance más reducido

El stash sirve para apartar trabajo temporalmente, no como arquitectura de multitarea continua.


50. Verifica antes de eliminar

Una secuencia segura:

git stash apply stash@{0}
git status
git diff
# run tests if relevant
git stash drop stash@{0}

No borres la copia de seguridad hasta saber que el estado restaurado es correcto.

Qué significa el resultado

Comando Qué hace
git stash push Guarda temporalmente los cambios con seguimiento, preparados o no
git stash push -u Incluye también los archivos sin seguimiento
git stash push -a Incluye también los archivos ignorados
git stash list Lista las entradas de stash
git stash show -p Muestra el patch del stash
git stash apply Restaura el stash pero conserva la entrada
git stash pop Restaura el stash y normalmente elimina la entrada si tiene éxito
git stash apply --index Intenta restaurar también el estado preparado
git stash drop Elimina una entrada de stash
git stash clear Elimina todas las entradas de stash
git stash branch Crea una rama desde la base original del stash y lo aplica

El patrón de restauración más seguro es:

inspeccionar
→ apply
→ verificar
→ drop

Qué revisar

Los archivos nuevos desaparecieron después del stash

Probablemente usaste:

git stash push

sin:

-u

Los archivos sin seguimiento no se incluyen por defecto.

El stash se aplica con conflictos

La rama de destino ha cambiado desde que se creó el stash.

Usa:

git status

resuelve manualmente, o plantéate usar:

git stash branch

desde la base original del stash.

pop no eliminó el stash

Comprueba:

git stash list

Es posible que un conflicto haya hecho que Git lo conserve.

La división entre preparado y no preparado cambió después de aplicar

Usa:

git stash apply --index

cuando importe conservar el estado del índice.

Tienes muchos stashes antiguos

Se está guardando trabajo importante en el lugar equivocado.

Convierte los stashes útiles en ramas y commits, y elimina los obsoletos de forma deliberada.

Notas de producción

Los stashes son estado local

No sustituyen a una copia de seguridad en el remoto.

Si el trabajo importa, haz commit en una rama y haz push cuando corresponda.

apply es más seguro que pop para el trabajo importante

apply mantiene el stash disponible hasta la verificación.

Así tienes una alternativa si la resolución de conflictos o el estado restaurado son incorrectos.

Los archivos sin seguimiento e ignorados requieren opciones explícitas

Usa:

-u

para los archivos sin seguimiento.

Usa:

-a

solo cuando de verdad haya que incluir los archivos ignorados.

Los conflictos de stash son normales cuando las ramas divergen

Un stash es una instantánea similar a un patch, tomada sobre un estado anterior del repositorio.

Cuanto más tiempo pasa guardado, más probables son los conflictos al aplicarlo.

Los stashes pueden contener archivos sensibles

Usar -a puede guardar configuración local ignorada o archivos que contienen secretos.

Siguen siendo objetos locales de Git.

Evita incluir secretos sin necesidad.

El trabajo de larga duración pertenece a una rama

Las ramas y los commits ofrecen una recuperación más clara, historial, integración con CI y copia de seguridad en el remoto.

Errores comunes

1. Suponer que los archivos sin seguimiento se guardan automáticamente

Usa -u cuando haya que incluir archivos nuevos.

2. Usar pop antes de inspeccionar un stash antiguo

Prefiere show + apply para el trabajo importante.

3. Borrar todos los stashes a la ligera

git stash clear elimina todas las entradas de stash.

4. Tratar el stash como una copia de seguridad duradera

Los stashes son locales y es fácil olvidarlos o borrarlos.

5. Guardar archivos ignorados con -a sin revisarlos

Podrías incluir secretos locales o directorios generados enormes.

6. Suponer que el estado preparado siempre se restaura exactamente

Usa --index cuando eso importe.

7. Eliminar un stash antes de probar el trabajo restaurado

Conserva la copia de seguridad hasta terminar la verificación.

8. Dejar los stashes sin nombre

Varias entradas llamadas «WIP» se vuelven difíciles de distinguir.

9. Aplicar un stash muy antiguo sobre una rama que ha cambiado mucho

Usa git stash branch si la aplicación directa genera muchos conflictos.

10. Usar el stash para gestionar varias tareas de larga duración

Usa ramas o worktrees en su lugar.

Siguiente paso

Usa la situación para elegir el flujo de stash más seguro.

  • Necesitas un cambio de contexto rápido → haz stash con un mensaje descriptivo.
  • Los archivos nuevos forman parte del trabajo → añade -u.
  • Los archivos ignorados también deben apartarse → usa -a solo después de evaluar el riesgo.
  • El trabajo es valioso → usa apply, verifica y luego haz drop.
  • Necesitas el estado preparado original → usa apply --index.
  • El stash es antiguo y genera muchos conflictos → usa git stash branch.
  • Se están acumulando muchos stashes → convierte los importantes en ramas y commits.
  • El trabajo necesita copia de seguridad en el remoto → haz commit en una rama y push; no dependas del stash.
  • Crees que eliminaste un stash por accidente → detén cualquier limpieza o GC e investiga de inmediato el reflog y los objetos inalcanzables.

← Todas las guías rápidas