Guardar el Trabajo en Progreso

Introducción

¡Bienvenido de nuevo, explorador de Git! Hoy nos sumergiremos en una de las funciones más útiles de Git para gestionar tu trabajo en curso: el stash (u ocultación). ¿Alguna vez has estado a mitad del desarrollo de una funcionalidad cuando, de repente, necesitas cambiar a una tarea diferente? ¡Git stash está aquí para salvarte el día!

Imagina Git stash como un cajón mágico donde puedes guardar temporalmente tu trabajo inacabado. Te permite cambiar de contexto rápidamente sin tener que realizar un commit de un trabajo hecho a medias. Esto es increíblemente útil cuando necesitas cambiar de rama, descargar actualizaciones o corregir un error urgente de último minuto.

En este laboratorio, exploraremos cómo usar Git stash para guardar tu trabajo en progreso, cómo aplicar los cambios guardados, crear ramas a partir de stashes, gestionar múltiples elementos en el stash y limpiar tu historial. Al finalizar esta sesión, tendrás una nueva y poderosa herramienta en tu arsenal de Git que hará que tu flujo de trabajo sea más fluido y flexible.

¡Comencemos a desbloquear el poder de Git stash!

Configuración de tu Espacio de Trabajo

Antes de profundizar en el uso del stash, configuremos un espacio de trabajo para experimentar. Crearemos un nuevo directorio, inicializaremos un repositorio Git y añadiremos contenido inicial.

Abre tu terminal y escribe estos comandos:

cd ~/project
mkdir git-stash-lab
cd git-stash-lab
git init
echo "## Git Stash Lab" > README.md
git add README.md
git commit -m "Initial commit"

Analicemos qué hacen estos comandos:

1. cd ~/project: Cambia tu directorio actual a la carpeta "project" en tu directorio personal.
2. mkdir git-stash-lab: Crea un nuevo directorio llamado "git-stash-lab".
3. cd git-stash-lab: Te sitúa dentro del directorio recién creado.
4. git init: Inicializa un nuevo repositorio Git en el directorio actual.
5. echo "## Git Stash Lab" > README.md: Crea un nuevo archivo llamado "README.md" con el contenido "## Git Stash Lab".
6. git add README.md: Prepara el nuevo archivo para el commit (lo añade al staging area).
7. git commit -m "Initial commit": Crea tu primer commit con los cambios preparados.

¡Genial! Ahora tenemos un repositorio con un commit. Verifiquemos el estado:

git status

Deberías ver un mensaje indicando que el árbol de trabajo está limpio (working tree clean). ¡Esto significa que estamos listos para empezar a experimentar con Git stash!

Si encuentras algún problema, asegúrate de estar en el directorio correcto y de que Git esté instalado correctamente en tu sistema. Puedes verificar tu instalación de Git ejecutando git --version.

Guardando Cambios en el Stash

Ahora que tenemos nuestro espacio de trabajo configurado, realicemos algunos cambios y aprendamos cómo ocultarlos temporalmente.

Primero, hagamos algunas modificaciones en nuestro archivo README.md:

echo "This is a work in progress" >> README.md

Este comando añade una nueva línea a nuestro archivo README.md. Vamos a crear también un archivo nuevo:

echo "Some important notes" > notes.txt

Ahora, si ejecutamos git status, veremos que tenemos tanto archivos modificados como archivos sin seguimiento (untracked):

git status

Deberías ver una salida indicando que README.md ha sido modificado y que notes.txt no tiene seguimiento.

Imagina que en este punto necesitas cambiar rápidamente a otra tarea, pero no estás listo para hacer un commit de estos cambios. ¡Aquí es donde git stash resulta útil!

Para guardar tus cambios en el stash, ejecuta:

git stash

Deberías ver una salida similar a esta:

Saved working directory and index state WIP on master: 1234567 Initial commit

Ahora, si ejecutas git status de nuevo, notarás algo interesante:

git status

Verás que, aunque README.md ya no aparece como modificado, notes.txt sigue figurando como un archivo sin seguimiento. Este es un punto crucial sobre git stash:

Importante: Por defecto, git stash solo guarda:

1. Cambios en archivos rastreados (archivos que Git ya conoce).
2. Cambios que ya están en el staging area.

Los archivos sin seguimiento (como nuestro notes.txt) no se incluyen en el stash de forma predeterminada. Este comportamiento garantiza que Git no oculte accidentalmente archivos nuevos que quizás no quieras incluir en el repositorio.

Si deseas incluir los archivos sin seguimiento en tu stash, puedes usar la opción -u (o --include-untracked):

git stash -u

Después de ejecutar este comando, tanto los cambios en README.md como el nuevo archivo notes.txt se guardarán en el stash.

Para ver qué hay en tu lista de stashes, puedes usar:

git stash list

Deberías ver una o dos entradas en el stash, dependiendo de si usaste la opción -u.

Presiona q para salir de la vista de la lista de stashes.

Recuerda, el stash es perfecto para cambios rápidos de contexto. Sin embargo, no es un sustituto de los commits en tu flujo de trabajo a largo plazo. Los stashes están pensados para ser un almacenamiento temporal.

Aplicando Cambios del Stash

Ahora que hemos guardado nuestros cambios, aprendamos cómo recuperarlos. Existen dos comandos principales para esto: git stash apply y git stash pop.

Empecemos con git stash apply:

git stash apply

Tras ejecutar este comando, podrías notar algo inesperado. Comprobemos el estado:

git status

Deberías ver una salida similar a esta:

On branch master
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        notes.txt

nothing added to commit but untracked files present (use "git add" to track)

Sorprendentemente, solo verás notes.txt como archivo sin seguimiento y no verás ningún cambio en README.md. Esto sucede porque:

1. En el Paso 2, primero usamos git stash sin la opción -u, lo que solo guardó los cambios de README.md.
2. Luego usamos git stash -u, que guardó el archivo notes.txt (README.md ya estaba limpio por el stash anterior).
3. Cuando aplicamos el stash, Git aplica el más reciente (el creado con -u), que solo contiene notes.txt, por lo que no ves los cambios de README.md.

Para ver todos los cambios, incluidos los de README.md, puedes usar:

git stash apply stash@{1}

Ahora, si revisas el estado de nuevo, deberías ver tanto los cambios en README.md como notes.txt como archivo sin seguimiento.

Esta situación resalta un aspecto importante al trabajar con stashes: el orden en que los creas y los aplicas puede afectar el resultado. Siempre es una buena práctica verificar el contenido de tus stashes antes de aplicarlos, especialmente cuando manejas varios.

La diferencia entre apply y pop es que apply mantiene los cambios en tu lista de stashes, mientras que pop los elimina de la lista después de aplicarlos.

git stash clear
git stash -u
git stash list

Primero limpiamos todos los stashes para empezar de cero, luego guardamos nuestros cambios con la opción -u para incluir archivos sin seguimiento. Finalmente, listamos nuestros stashes para verificar que se haya creado correctamente.

Vamos a guardar nuestros cambios de nuevo y probar pop:

git stash pop

Verás una salida similar a la anterior, pero si ejecutas git stash list ahora, verás que tu lista de stashes está vacía.

¿Por qué existen tanto apply como pop? apply es útil cuando quieres aplicar los mismos cambios guardados en múltiples ramas. pop es el más utilizado cuando simplemente vas a retomar el trabajo en la misma rama donde lo dejaste.

Creando una Rama desde un Stash

A veces, podrías darte cuenta de que los cambios que guardaste en el stash deberían estar en su propia rama. Git facilita esto con el comando git stash branch.

Primero, creemos algunos cambios nuevos y guardémoslos:

echo "Feature in progress" >> README.md
echo "More notes" >> notes.txt
git stash -u

Ahora, creemos una nueva rama con estos cambios:

git stash branch feature-branch

Este comando crea una nueva rama llamada "feature-branch", se cambia a ella (checkout) y luego aplica los cambios del stash. Acto seguido, el stash se elimina de tu lista.

Deberías ver una salida similar a esta:

Switched to a new branch 'feature-branch'
On branch feature-branch
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        notes.txt

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (1234567890abcdef1234567890abcdef12345678)

Esta función es particularmente útil cuando has guardado cambios experimentales y luego decides que vale la pena desarrollarlos en su propia rama independiente.

Recuerda que, tras crear una rama desde un stash, deberás realizar un commit de los cambios si deseas conservarlos:

git add README.md notes.txt
git commit -m "Start new feature"

Para volver a tu rama principal, usa:

git checkout master

Gestión de Múltiples Stashes

A medida que trabajas con Git, es posible que termines guardando varios conjuntos de cambios. Git te permite gestionar múltiples stashes fácilmente. Exploremos cómo crear, listar y administrar varios elementos en el stash.

Primero, creemos tres stashes con diferentes cambios:

## Primer stash
echo "Change 1" >> README.md
git stash push -m "First change"

## Segundo stash con archivo sin seguimiento
echo "Change 2" >> README.md
echo "Note 2" >> notes.txt
git stash push -u -m "Second change"

## Tercer stash
echo "Change 3" >> README.md
git stash push -m "Third change"

Nota: Notarás que ahora estamos usando git stash push en lugar de solo git stash. El subcomando push es la forma moderna y preferida de crear stashes, especialmente cuando quieres añadir mensajes personalizados con el indicador -m. Aunque git stash y git stash -u siguen funcionando (son atajos de git stash push), usar git stash push explícitamente te ofrece más control y claridad, sobre todo al gestionar múltiples stashes con mensajes descriptivos.

Analicemos lo que hicimos:

1. Creamos el primer stash con un cambio en README.md.
2. Creamos el segundo stash con un cambio en README.md y un nuevo archivo sin seguimiento.
3. Creamos el tercer stash con otro cambio en README.md.
4. Usamos el indicador -m para añadir mensajes descriptivos.
5. Usamos el indicador -u en el segundo stash para incluir el archivo sin seguimiento.

Ahora, listemos nuestros stashes:

git stash list

Deberías ver una salida similar a esta:

stash@{0}: On master: Third change
stash@{1}: On master: Second change
stash@{2}: On master: First change

Puedes examinar el contenido de un stash sin aplicarlo:

git stash show stash@{1}

Para ver más detalles, añade el indicador -p para ver el diff completo:

git stash show -p stash@{1}

Creemos dos stashes más para practicar la gestión de un conjunto mayor de cambios:

## Cuarto stash
echo "Change 4" >> README.md
git stash push -m "Fourth change"

## Quinto stash
echo "Change 5" >> README.md
git stash push -m "Fifth change"

Revisa tu lista de stashes de nuevo:

git stash list

Ahora deberías ver cinco stashes en tu lista:

stash@{0}: On master: Fifth change
stash@{1}: On master: Fourth change
stash@{2}: On master: Third change
stash@{3}: On master: Second change
stash@{4}: On master: First change

Gestionar múltiples stashes puede ser útil cuando estás haciendo malabares con varias tareas a la vez. Sin embargo, intenta no acumular demasiados, ya que puede volverse confuso. Considera el uso de ramas para trabajos a más largo plazo.

Recuerda: los stashes están diseñados para ser temporales. Si te encuentras manteniendo stashes durante mucho tiempo, considera usar ramas de funcionalidades o realizar commits de tus cambios.

Limpieza de Stashes

A medida que incorporas el stash en tu flujo de trabajo, podrías acumular elementos que ya no necesitas. Es una buena práctica limpiar tus stashes regularmente para mantener el orden.

Para eliminar un solo stash, puedes usar el comando drop que mencionamos anteriormente:

git stash drop stash@{2}

Esto elimina el tercer stash (el de "Third change") de nuestra lista.

Si deseas eliminar todos tus stashes a la vez, puedes usar:

git stash clear

¡Ten mucho cuidado con este comando! Eliminará todos tus stashes y la acción no se puede deshacer.

Otro comando útil es git stash pop, que vimos antes. Aplica el stash más reciente y luego lo elimina de la lista:

git stash pop

Recuerda que, por lo general, es recomendable mantener la lista de stashes corta. Están pensados para el almacenamiento temporal del trabajo en curso. Si acumulas muchos stashes, podría ser una señal de que deberías hacer commits con más frecuencia o crear ramas para trabajos de mayor duración.

Resumen

¡Felicidades, maestro de Git stash! Acabas de añadir una herramienta sumamente potente a tu repertorio de Git. Repasemos los conceptos clave que hemos cubierto:

1. Guardar Cambios (Stashing): Aprendiste a almacenar temporalmente tu trabajo en progreso usando git stash.
2. Aplicar Cambios Guardados: Descubriste cómo recuperar tus cambios usando git stash apply y git stash pop.
3. Crear Ramas desde Stashes: Viste cómo convertir un conjunto de cambios guardados en una nueva rama con git stash branch.
4. Gestión de Múltiples Stashes: Aprendiste a trabajar con varios stashes, aplicando y visualizando elementos específicos según sea necesario.
5. Limpieza de Stashes: Practicaste una buena higiene de Git al aprender a eliminar stashes individuales y a limpiar toda la lista.

Git stash es una funcionalidad increíblemente útil que te permite cambiar de contexto rápidamente sin comprometer trabajo incompleto. Es perfecto para esos momentos en los que necesitas alternar tareas o ramas de forma inmediata.

Recuerda que, aunque los stashes son útiles, su propósito es ser temporales. Para trabajos a largo plazo, suele ser mejor realizar un commit de tus cambios o crear una nueva rama. Usa los stashes con sabiduría y te ayudarán a mantener un flujo de trabajo ágil y flexible.