El comando Git Stash explicado con ejemplos sencillos (2026)

Git stash archiva temporalmente sus cambios no confirmados para que puedas cambiar de rama, extraer actualizaciones o ejecutar pruebas en un árbol de trabajo limpio sin perder trabajo.

Guarda los archivos modificados (y opcionalmente los archivos ignorados o no rastreados) en una pila como almacenamiento, lo que le permite volver a aplicarlos más tarde a través de git stash apply o quitar y aplicar en un solo paso con git stash pop.

Si alguna vez ha necesitado pausar lo que está haciendo, cambiar de tarea y regresar sin perder el progreso, git alijo El mando es tu mejor amigo.

En esta guía, explicaré el comando stash de Git con ejemplos simples, consejos profesionales y errores comunes basados ​​en flujos de trabajo reales utilizados en equipos de hosting, CI/CD y colaborativos.

¿Qué es Git Stash y cómo funciona?

Git stash toma su directorio de trabajo sucio (cambios aún no confirmados) y almacena esos cambios en una pila especial referenciada por refs/stashTu directorio de trabajo se limpia para que coincida con HEAD, lo que te permite cambiar de rama o extraer sin conflictos. Posteriormente, puedes volver a aplicar los cambios guardados en cualquier rama.

¿Qué se esconde?

• Cambios rastreados: Archivos modificados que Git ya rastrea.
• Archivos no rastreados: Sólo si lo usas --include-untracked or -u/-a.
• Archivos ignorados: Sólo si lo usas --all.
• Índice vs árbol de trabajo:Puede controlar si los cambios programados se mantienen programados utilizando --keep index.

Cuándo usar Git Stash

• Necesita cambiar de rama pero tienes ediciones locales que no estás listo para confirmar.
• Tú quieres extraer/rebasar de forma limpia y sin comprometer trabajos parciales.
• Eres experimentando y quiero una instantánea temporal segura.
• Su CI / CD o el flujo de trabajo de preparación requiere un árbol de trabajo limpio para probar una compilación.

Inicio rápido: Los comandos de Git Stash más útiles

Crear un Stash (guardar/enviar)

Usos modernos de Git git stash push (equivalente a git stash en muchos casos). Agrega un mensaje para que lo reconozcas más tarde.

# Stash tracked changes with a message
git stash push -m "WIP: homepage layout tweak"

# Include untracked files (e.g., new files)
git stash push -u -m "WIP: add ContactForm component"

# Include ignored files too (rare)
git stash push -a -m "Temp build outputs stashed"

Mira tus escondites

git stash list
git stash show -p stash@{0}   # show patch of a specific stash

Volver a aplicar vs. Volver a aplicar y eliminar

• Aplicar las repeticiones cambian pero mantiene El alijo: git stash apply
• Pop repite los cambios y elimina El alijo: git stash pop

# Apply the most recent stash
git stash apply

# Apply a specific stash
git stash apply stash@{2}

# Pop (apply and remove)
git stash pop
git stash pop stash@{1}

Limpiar escondites

# Remove one stash
git stash drop stash@{0}

# Remove all stashes
git stash clear

Crear una rama desde un alijo

# Great for turning WIP into a feature branch
git stash branch feature/new-ui stash@{0}

Ejemplos prácticos de Git Stash (paso a paso)

1) Guarde las ediciones locales para extraer el código más reciente

# You have uncommitted changes on main
git stash push -m "WIP: optimize hero image"

# Get the latest changes safely
git pull --rebase

# Reapply your work
git stash pop

Mantiene limpio su historial y reduce los conflictos de fusión al rebasarlo en confirmaciones nuevas y ascendentes.

2) Guardar solo ciertos archivos

# Only stash changes in src/components
git stash push -m "WIP: components only" -- src/components

# Only stash a single file
git stash push -m "WIP: header styles" -- src/styles/header.css

Pathspecs te permite limitar el alcance de tu inventario, lo que es perfecto para repositorios grandes en los que no se deben tocar cambios no relacionados.

3) Guarde archivos ignorados o sin seguimiento

# Include untracked files
git stash push -u -m "WIP: new config files"

# Include everything (tracked, untracked, ignored)
git stash push -a -m "WIP: stash node_modules & build"

Usa -a con cautela. Guardar carpetas grandes ignoradas (como node_modules/) puede ser lento y rara vez es necesario.

4) Resolver conflictos después de aplicar un Stash

If apply or pop Si se generan conflictos, Git marca los archivos como si se tratara de un conflicto de fusión. Corrígelos y márcalos como resueltos.

# After conflicts occur
git status
# Edit files and resolve conflict markers
git add <resolved-files>
# If you used pop and conflicts happened, the stash may still exist until resolution completes

5) Convertir un Stash en una rama de características

Convierte el trabajo en progreso en su propia rama sin afectar el actual.

git stash branch feature/login-ui stash@{0}
# Now commit changes on the new branch

Técnicas avanzadas de almacenamiento en Git

Agregar un mensaje descriptivo

# Always describe your stash for future you (or teammates)
git stash push -m "WIP: refactor API client for retries"

Mantenga los cambios programados en etapas

Usa --keep-index Para almacenar solo los cambios no programados. Ideal cuando tu confirmación está a medio terminar, pero necesitas pausarla.

# Keeps staged changes intact; stashes only unstaged edits
git stash push --keep-index -m "Pause: tests failing, keep staged fix"

Stash interactivo (modo parche)

Seleccione fragmentos específicos para guardar, útil cuando un archivo contiene partes listas para confirmar y otras aún experimentales.

git stash push -p -m "WIP: stash only parts of file"

Comparar Apply vs Pop vs Branch

• aplicar: Es más seguro cuando no estás seguro de que se volverá a aplicar limpiamente (el material almacenado permanece si ocurren conflictos).
• estallido: Más rápido cuando tienes confianza, aplica y quita el contenido en un solo paso.
• rama: Ideal para aislar WIP en su propia rama para revisión de código o CI.

Errores comunes y cómo evitarlos

• Olvidar lo que hay en un escondite: Siempre usa -m mensajes y git stash show -p antes de presentar tu solicitud
• Usando pop cuando es probable que haya conflictos: Utilice apply, verificar el resultado, luego manualmente drop.
• Ocultar carpetas ignoradas masivas: Evitando -a A menos que sea esencial. Ralentiza las operaciones y puede inflar los metadatos del repositorio.
• Confiar en el alijo como almacenamiento a largo plazo: Stash es para alternar tareas a corto plazo. Conviértalo en una rama cuando el trabajo se extienda más allá de un día.

Flujo de trabajo del mundo real: equipos, CI/CD y alojamiento

En equipos de rápido movimientoA menudo, usarás stash para ejecutar correcciones rápidas o obtener actualizaciones antes de un lanzamiento. En combinación con la revisión de código y la integración continua, stash mantiene tu copia de trabajo limpia sin contaminar el historial con confirmaciones de "WIP".

• Antes de rebasear: git stash push, git pull --rebase, luego git stash pop.
• Antes de la revisión urgente: Guarde su trabajo actual, extraiga la rama de revisión, aplique el parche, impleméntelo y luego regrese y explórelo.
• Para puesta en escena/prueba: Mantenga el WIP fuera de la rama de preparación; convierta los escondites críticos en una rama de características (git stash branch ...) para pruebas de CI.

Si utiliza manageAlojamiento d con flujos de trabajo Git, busque entornos de prueba que admitan implementaciones basadas en sucursales. En YouStableNuestro alojamiento fácil de usar para desarrolladores facilita la creación de sitios de prueba por rama, de modo que puede activar un git stash en una rama de características adecuada y probar los cambios de forma segura, sin poner en riesgo la producción.

Solución de problemas de Git Stash

"¿A dónde fue mi escondite?"

Ejecutar git stash listSi eliminaste accidentalmente un stash, revisa el registro de referencias. Las entradas del stash son confirmaciones; a veces puedes recuperarlas.

# Show stash stack
git stash list

# Inspect HEAD and stash movements
git reflog

# If you spot the lost commit hash, create a branch to recover
git branch rescue <commit-hash>

Se aplicó el alijo equivocado

Usa git reset --hard Para revertir su árbol de trabajo a una confirmación conocida (cuidado: descarta los cambios no confirmados). O bien, confirme el estado no deseado y revertirlo mediante una nueva confirmación, más seguro en ramas compartidas.

Conflictos de Stash al aplicar/extraer

• Inspeccionar conflictos: git status
• Resolver marcadores en archivos: <<<<<<<, =======, >>>>>>>
• Mark resolvió: git add
• Completa la solicitud: si usa popAsegúrese de que esté terminado; de lo contrario, vuelva a aplicarlo con cuidado.

Mejores prácticas para usar Git Stash

• Prefiera compromisos pequeños y frecuentes para trabajos compartibles; use stash para cambios de contexto cortos y privados.
• Ponle nombre a tus escondites con -m para mayor claridad durante los sprints intensos.
• Usar aplicar antes de pop cuando anticipa conflictos o está volviendo a presentar solicitudes en distintas sucursales.
• Convertir escondites de larga duración en ramas de características: git stash branch.
• Mantenga la pila ordenada:Deja caer o limpia los escondites que ya no necesitas.

Referencia de comandos de Git Stash (hoja de referencia)

# Save changes
git stash push -m "message"
git stash push -u -m "include untracked"
git stash push -a -m "include ignored"

# Inspect
git stash list
git stash show -p stash@{n}

# Reapply
git stash apply [stash@{n}]
git stash pop [stash@{n}]

# Remove
git stash drop [stash@{n}]
git stash clear

# Branch from stash
git stash branch <branch-name> [stash@{n}]

# Partial/interactive
git stash push -p -m "partial stash"

# Keep staged changes
git stash push --keep-index -m "keep index"

Preguntas Frecuentes

Conclusión

Git stash Es una potente red de seguridad para desarrolladores: preserva el impulso, reduce los problemas de fusión y mantiene limpio el historial. Usa mensajes, aplica antes de la extracción cuando no estés seguro y ramifica los escondites para el trabajo en curso.

Construir y probar en ramas de ensayo como las admitidas en YouStableEl alojamiento compatible con Git de 's le ayuda a realizar envíos con confianza sin perder una línea de código.