Una guía completa de Git Stash

Estás en plena implementación de una funcionalidad, sumergido en una refactorización, cuando un compañero de equipo te avisa sobre un bug crítico en producción. Tu directorio de trabajo es un caos de cambios a medio terminar. No estás listo para hacer commit, pero tampoco puedes cambiar de rama con trabajo sin confirmar dando vueltas.

Para esto sirve exactamente git stash. Esta guía cubre todos los comandos de git stash que realmente vas a usar, cómo manejar conflictos y los consejos de flujo de trabajo que hacen que usar stash se sienta natural en lugar de arriesgado.

¿Qué es Git Stash?

git stash guarda tus cambios sin confirmar—tanto los que están en el staging como los que no—en una pila local y revierte tu directorio de trabajo para que coincida con el último commit (HEAD). Puedes restaurar esos cambios más tarde, en la misma rama o en una diferente.

Los stashes son solo locales. No se envían a tu remoto con git push, ni se comparten con tus compañeros de equipo.

Lo que se guarda en el stash por defecto:

• Cambios en el staging (index)
• Cambios sin staging en archivos rastreados

Lo que NO se guarda en el stash por defecto:

• Archivos sin rastrear (archivos nuevos que aún no se han añadido a Git)
• Archivos ignorados

Comandos principales de Git Stash

Guardar cambios con git stash push

git stash

El simple git stash es una abreviatura de git stash push. Es la forma más rápida de obtener un directorio de trabajo limpio.

Añade un mensaje descriptivo para saber qué contiene más adelante:

git stash push -m "WIP: refactor auth middleware"

Nota: La sintaxis más antigua git stash save está obsoleta. Usa git stash push en su lugar.

Guardar archivos sin rastrear

Por defecto, los archivos nuevos que aún no has añadido al staging se quedan fuera. Usa -u para incluirlos:

git stash push -u -m "WIP: new login component"

Para también guardar archivos que coinciden con .gitignore, usa -a (--all). Esto rara vez es necesario, pero resulta útil cuando los archivos ignorados podrían interferir con un cambio de rama o una compilación.

Guardar archivos específicos

Puedes guardar solo ciertos archivos usando un pathspec:

git stash push -m "WIP: api changes" -- src/api/client.js src/api/utils.js

Esto deja todo lo demás en tu directorio de trabajo intacto.

Listar tus stashes

git stash list

Salida:

stash@{0}: On main: WIP: refactor auth middleware
stash@{1}: WIP on feature/login: 9ab3c12 Add login form

Los stashes se almacenan en una pila tipo LIFO (último en entrar, primero en salir). stash@{0} siempre es el más reciente.

Inspeccionar un stash antes de aplicarlo

git stash show stash@{0}        # resumen
git stash show -p stash@{0}     # diff completo

Git Stash Pop vs Apply: ¿Cuál deberías usar?

Esta es una de las fuentes de confusión más comunes con los comandos de git stash.

Usa pop cuando hayas terminado con el stash y solo quieras recuperar tus cambios. Usa apply cuando quieras aplicar el mismo stash a varias ramas, o cuando quieras probar el resultado antes de comprometerte a eliminarlo.

Para aplicar un stash específico:

git stash pop stash@{1}
git stash apply stash@{1}

Restaurar el estado de staging con --index

Por defecto, al aplicar un stash se restauran todos los cambios como sin staging. Si quieres restaurar la distinción entre staged y unstaged tal como estaba cuando hiciste el stash, usa --index:

git stash pop --index

Resolver conflictos al aplicar un stash

Si la rama ha cambiado desde que hiciste el stash, puedes encontrarte con conflictos:

CONFLICT (content): Merge conflict in src/api/client.js
The stash entry is kept in case you need it again.

Tanto pop como apply mantienen el stash en la pila cuando se producen conflictos. Para resolverlos:

1. Ejecuta git status para encontrar los archivos en conflicto.
2. Abre cada archivo y resuelve los marcadores de conflicto.
3. Añade los archivos resueltos al staging: git add src/api/client.js.
4. Elimina el stash manualmente cuando estés satisfecho: git stash drop stash@{0}.

Cuando los conflictos se complican: usa git stash branch

Si los conflictos son demasiado enredados, git stash branch es la vía de escape más limpia. Crea una nueva rama desde el commit exacto donde hiciste el stash, y luego aplica el stash allí. Como la rama parte del commit donde se creó el stash, esto suele evitar los conflictos:

git stash branch fix/auth-refactor stash@{0}

Si la aplicación es exitosa, el stash se elimina automáticamente.

Gestionar y limpiar stashes

git stash drop stash@{0}   # eliminar un stash específico
git stash clear            # eliminar TODOS los stashes (irreversible)

⚠️ git stash clear es permanente. No hay forma de deshacerlo. Verifica dos veces antes de ejecutarlo.

Avanzado: stashing parcial y stash solo del staging

El modo de parche interactivo te permite elegir qué hunks guardar en el stash:

git stash push -p

Git te guía a través de cada cambio y te pregunta si quieres guardarlo. Útil cuando un archivo tiene cambios relacionados y no relacionados.

Guardar solo los cambios en staging (Git 2.35 y posteriores):

git stash push --staged

Esto guarda lo que está en tu index y deja el trabajo sin staging en su lugar—práctico para aislar un cambio que quieres apartar sin perder tu progreso actual.

Mantener los cambios en staging dentro del index mientras guardas todo lo demás:

git stash push --keep-index

Ten en cuenta que --keep-index aún guarda tanto los cambios en staging como los que no; simplemente deja los que están en staging en su lugar en tu directorio de trabajo después del stash.

Recuperar un Git Stash eliminado

Si accidentalmente eliminas o limpias los stashes, puede que aún sean recuperables como commits colgantes (dangling commits) en tu repositorio. Las entradas de stash se almacenan como merge commits, por lo que puedes buscarlas con:

git fsck --unreachable | grep commit | cut -d' ' -f3 | xargs git log --merges --no-walk --grep=WIP

Esto lista los merge commits inalcanzables que parecen entradas de stash. Una vez que encuentres el hash del commit que quieres, restáuralo con:

git stash apply <commit-hash>

La recuperación no está garantizada—el recolector de basura de Git eventualmente eliminará los objetos inalcanzables—así que actúa rápido.

Transferir stashes entre máquinas

Las versiones recientes de Git añadieron git stash export y git stash import, que permiten transferir stashes usando los flujos normales de fetch y push.

Para versiones anteriores de Git, o para transferencias simples y puntuales, las alternativas prácticas siguen incluyendo:

• Exportar como parche: git stash show -p stash@{0} > my-stash.patch, luego aplícalo en otro lugar con git apply my-stash.patch.
• Confirmarlo en una rama desechable: crea una rama, confirma el trabajo, súbela a un remoto, luego haz pull y reset en la otra máquina.

Los parches suelen ser el camino más sencillo para transferencias puntuales.

Buenas prácticas para Git Stash

• Siempre añade un mensaje. git stash push -m "WIP: qué y por qué" te ahorra tener que mirar una lista de entradas anónimas tipo WIP on main.
• El stash es almacenamiento temporal, no una copia de seguridad. Haz commit de tu trabajo cuando alcance un punto de control lógico.
• Mantén tu lista de stashes corta. Revísala regularmente y elimina los stashes que ya no necesites.
• Haz pull antes de hacer pop. Actualizar tu rama antes de restaurar un stash reduce la posibilidad de conflictos.
• Prefiere apply sobre pop cuando tengas dudas. Siempre puedes eliminar el stash manualmente una vez que hayas confirmado que todo se ve bien.

Referencia rápida: Comandos de Git Stash

Conclusión

git stash es uno de esos comandos que parece opcional hasta que realmente lo necesitas—y entonces se vuelve parte de tu flujo de trabajo diario. Los hábitos clave: siempre nombra tus stashes, mantén la lista limpia y recurre a git stash branch cuando los conflictos hagan que un simple pop sea poco práctico. Bien utilizado, el stashing mantiene tu historial de Git limpio y tus cambios de contexto sin dolor.

Preguntas frecuentes

Gain control over your UX

See how users are using your site as if you were sitting next to them, learn and iterate faster with OpenReplay. — the open-source session replay tool for developers. Self-host it in minutes, and have complete control over your customer data. Check our GitHub repo and join the thousands of developers in our community.