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