Le Tisseur de Temps

git stash - Geler et reprendre ton travail

Le problème : l'urgence en plein travail

Imagine la situation : tu es en train de modifier un fichier important. Ton travail n'est pas terminé - tu ne veux pas faire un commit avec du code à moitié fini. Et soudain, on te signale un bug critique sur une autre branche qui doit être corrigé immédiatement.

Tu ne peux pas changer de branche avec des modifications non committées - Git risque de refuser ou, pire, de mélanger tes changements en cours avec la branche cible.

git stash - Geler ton travail en cours

La commande git stash prend toutes tes modifications en cours (indexées et non indexées) et les met de côté dans une pile temporaire. Ton répertoire de travail redevient propre, comme si tu n'avais rien touché.

git stash

C'est comme appuyer sur "pause" : tout est sauvegardé, mais invisible. Tu peux maintenant changer de branche en toute sécurité.

Stash avec un message descriptif

Par défaut, le stash est nommé automatiquement d'après le dernier commit. Mais quand tu accumules plusieurs stashes, c'est vite illisible. Utilise l'option -m pour ajouter un message clair :

git stash push -m "Chronique du dragon : chapitre 3 en cours"

git stash list - Voir tes stashes

La commande git stash list affiche tous les stashes empilés :

git stash list

Résultat :

stash@{0}: On main: Chronique du dragon : chapitre 3 en cours
stash@{1}: WIP on main: abc1234 Ajouter le titre

git stash show - Prévisualiser un stash

Avant de restaurer un stash, tu peux voir ce qu'il contient :

# Résumé des fichiers modifiés
git stash show

# Diff complet
git stash show -p

# Un stash spécifique
git stash show stash@{1}

C'est comme jeter un œil dans le tiroir sans en sortir le contenu.

git stash pop - Restaurer et supprimer

La commande git stash pop restaure le stash le plus récent et le supprime de la pile :

git stash pop

C'est l'opération la plus courante : tu récupères ton travail et le stash disparaît.

Tu peux aussi restaurer un stash spécifique :

git stash pop stash@{2}

git stash apply - Restaurer sans supprimer

Parfois, tu veux restaurer un stash mais le garder dans la pile (par exemple, pour l'appliquer sur plusieurs branches) :

git stash apply

La différence avec pop :

git stash drop et git stash clear - Faire le ménage

Pour supprimer un stash spécifique sans le restaurer :

# Supprimer le stash le plus récent
git stash drop

# Supprimer un stash spécifique
git stash drop stash@{1}

Pour tout supprimer d'un coup :

git stash clear

Stasher des fichiers spécifiques

Par défaut, git stash met de côté toutes les modifications. Mais tu peux cibler des fichiers précis :

git stash push -m "Juste le rapport" rapport.txt

Les autres fichiers modifiés restent en place. C'est utile quand tu veux mettre de côté seulement une partie de ton travail.

Le workflow complet : stash dans la vraie vie

Voici le scénario typique d'utilisation du stash :

1. Tu travailles sur une fonctionnalité (branche main ou feature)
2. Urgence ! Un bug critique est signalé
3. git stash push -m "feature X en cours"    # geler le travail
4. git switch correctif-urgent               # changer de branche
5. ... corriger le bug, committer ...
6. git switch main                           # revenir
7. git stash pop                             # reprendre le travail

C'est fluide, rapide, et tu ne perds rien.

Exercice pratique - L'Urgence du Dragon

Étape 1 - Créer le dépôt et le premier commit

mkdir tisseur-de-temps
cd tisseur-de-temps
git init -b main
echo "# Chroniques du Royaume" > chronique.txt
echo "" >> chronique.txt
echo "Les temps sont calmes dans le royaume." >> chronique.txt
git add chronique.txt
git commit -m "Créer le registre des chroniques"

Étape 2 - Commencer à travailler sur une chronique

Tu commences à rédiger un nouveau chapitre :

echo "" >> chronique.txt
echo "## Chapitre 2 - Les moissons" >> chronique.txt
echo "Les récoltes de cette année sont abondantes..." >> chronique.txt

Vérifie que tu as bien des modifications en cours :

git status

Tu devrais voir chronique.txt dans les fichiers modifiés. Ne committe pas - le chapitre n'est pas terminé.

Étape 3 - L'urgence ! Stasher le travail

Tu dois mettre ton travail de côté :

git stash push -m "Chapitre 2 en cours de rédaction"

Vérifie que ton répertoire est propre :

git status
git stash list

Étape 4 - Traiter l'urgence sur une nouvelle branche

git switch -c rapport-dragon
echo "# ALERTE - Rapport de Dragon" > alerte.txt
echo "" >> alerte.txt
echo "Un dragon a été aperçu dans les montagnes du nord." >> alerte.txt
echo "Les défenses sont en cours de mobilisation." >> alerte.txt
git add alerte.txt
git commit -m "Rédiger le rapport d'alerte dragon"

Étape 5 - Revenir à la branche principale

L'urgence est traitée, retour à ton travail :

git switch main

Étape 6 - Récupérer le travail en cours

git stash pop

Vérifie que tes modifications sont revenues :

git status
cat chronique.txt

Tu devrais retrouver le chapitre 2 en cours, exactement comme tu l'avais laissé.

Étape 7 - Terminer et committer

echo "Les greniers sont pleins, le peuple est serein." >> chronique.txt
git add chronique.txt
git commit -m "Rédiger le chapitre 2 des chroniques"

Étape 8 - Vérifier l'historique

git log --oneline --all --graph

Étape 9 - Lancer la vérification

bash verifier.sh

.\verifier.ps1

Récapitulatif des commandes