Git stash et git clean : mettre de côté et nettoyer

git stash met vos modifications de côté dans une pile temporaire, et git clean supprime les fichiers non suivis. Ces deux commandes gardent votre répertoire de travail propre quand vous devez changer de contexte. Ce guide vous apprend à utiliser toutes les options utiles de stash (-u, --patch, --keep-index), à récupérer un stash perdu et à nettoyer sélectivement avec git clean.

Prérequis : Enregistrer des modifications et Les branches en bref.

Ce que vous allez apprendre

Stasher et récupérer des modifications en cours sans créer de commit
Utiliser les options avancées : -u (untracked), --patch, --keep-index
Gérer plusieurs stashes et les nommer pour s'y retrouver
Nettoyer le répertoire de travail avec git clean pour repartir sur une base propre

`git stash` : sauvegarder temporairement

Le cas d'usage typique

Vous travaillez sur une feature quand un bug urgent arrive. Votre working directory est sale, impossible de changer de branche :

git stash
# Saved working directory and index state WIP on feature: a1b2c3d ...
git switch main
# ... corriger le bug ...
git switch feature
git stash pop

git stash sauvegarde les fichiers modifiés et l'index (staging area) dans une pile, puis restaure un working directory propre.

Commandes essentielles

La distinction à retenir dans ce bloc est celle entre pop et apply. pop retire l'entrée de la pile après l'avoir appliquée, apply la conserve. Réflexe utile : quand vous n'êtes pas certain que le stash s'appliquera proprement, utilisez apply, vérifiez le résultat, puis supprimez l'entrée avec drop. Attention aussi à la numérotation : stash@{0} désigne toujours le plus récent, donc les numéros se décalent après chaque pop ou drop.

# Sauvegarder (avec un message descriptif)
git stash push -m "wip: calcul de remise"

# Lister les stash
git stash list
# stash@{0}: On feature: wip: calcul de remise
# stash@{1}: WIP on main: fix header

# Appliquer le dernier stash ET le supprimer de la pile
git stash pop

# Appliquer SANS supprimer (utile pour appliquer sur plusieurs branches)
git stash apply

# Appliquer un stash spécifique
git stash apply stash@{1}

# Supprimer un stash
git stash drop stash@{0}

# Vider toute la pile
git stash clear

Options avancées de `git stash push`

Deux options de ce tableau modifient ce qui entre dans le stash (-u, -a, et la forme -- fichier), les autres modifient ce qui reste dans votre répertoire de travail après l'opération. Ne les confondez pas : --keep-index n'allège pas le stash, il change seulement l'état du disque après coup. C'est le piège le plus fréquent de cette commande.

Option	Effet
`-m "message"`	Ajoute un message descriptif
`--keep-index`	Stashe tout, mais laisse les modifications déjà stagées en place dans l'index et sur le disque
`--include-untracked` / `-u`	Inclut aussi les fichiers non suivis (nouveaux fichiers)
`--all` / `-a`	Inclut tout, même les fichiers ignorés par `.gitignore`
`--patch` / `-p`	Sélection interactive (hunk par hunk)
`-- fichier1 fichier2`	Stashe uniquement les fichiers spécifiés

Exemples :

# Stasher uniquement les modifications non stagées
git stash push --keep-index -m "non stagé uniquement"

# Stasher aussi les nouveaux fichiers
git stash push -u -m "avec les nouveaux fichiers"

# Stasher un seul fichier
git stash push -m "config only" -- src/config.py

Créer une branche depuis un stash

Si vos modifications de stash causent des conflits au pop :

git stash branch nouvelle-branche stash@{0}

Git crée la branche depuis le commit où le stash a été fait, applique le stash, et le supprime de la pile. Pas de conflit possible.

Voir le contenu d'un stash

Inspecter avant d'appliquer évite la plupart des pop malheureux, en particulier quand la pile contient plusieurs entrées créées à des jours d'intervalle. Sans argument, git stash show porte sur stash@{0}. Un point qui surprend souvent : la sortie par défaut n'inclut pas les fichiers non suivis, même s'ils ont été stashés avec -u. Ajoutez -u à show pour les voir.

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

# Diff complet
git stash show -p

# Diff d'un stash spécifique
git stash show -p stash@{2}

`git clean` : supprimer les fichiers non suivis

git clean supprime les fichiers et dossiers qui ne sont pas versionnés par Git. C'est l'outil de nettoyage du working directory.

Toujours commencer par un dry-run

Le dry-run doit porter exactement les mêmes options que la commande réelle, sinon il ne prouve rien. C'est particulièrement vrai pour -d : sans lui, git clean ignore les répertoires non suivis, et vous obtenez une liste rassurante qui ne reflète pas ce que fera git clean -fd. Comparez les deux sorties ci-dessous, le répertoire temp/ n'apparaît que dans la seconde.

# Sans -d : les répertoires non suivis sont ignorés
git clean -n
# Would remove build.log
# Would remove debug.out

# Avec -d : le répertoire temp/ apparaît enfin
git clean -nd
# Would remove build.log
# Would remove debug.out
# Would remove temp/

# Supprimer pour de vrai (nécessite -f)
git clean -fd

Options de `git clean`

Les deux options qui décident réellement du périmètre de suppression sont -x et -X, et une majuscule les sépare. Le -x minuscule ajoute les fichiers ignorés à la liste, donc supprime tout ce qui n'est pas versionné. Le -X majuscule restreint aux seuls fichiers ignorés, ce qui préserve les nouveaux fichiers que vous n'avez pas encore ajoutés au dépôt. Sur un poste de travail, -X est presque toujours le bon choix, -x étant réservé au cas où vous voulez réellement un dépôt identique à un git clone frais.

Option	Effet
`-f`	Force, obligatoire pour supprimer
`-n`	Dry-run, affiche sans supprimer
`-d`	Supprime aussi les dossiers non suivis
`-x`	Supprime aussi les fichiers ignorés (`.gitignore`)
`-X`	Supprime uniquement les fichiers ignorés
`-i`	Mode interactif
`-e <motif>`	Exclut un motif de la suppression

Exemples courants :

# Supprimer fichiers + dossiers non suivis
git clean -fd

# Tout supprimer (y compris les ignorés) : reset complet
git clean -fdx

# Supprimer uniquement les artefacts de build (fichiers ignorés)
git clean -fdX

# Mode interactif (le plus sûr)
git clean -i

`git clean -i` : le mode interactif

Le mode interactif est la seule variante de git clean qui ne demande pas -f : elle vous fait valider avant chaque suppression, ce qui remplace la protection du flag de forçage. C'est le mode à privilégier quand la liste du dry-run contient un fichier dont vous n'êtes pas sûr. Comme pour le dry-run, pensez à ajouter -d si vous voulez que les répertoires non suivis apparaissent dans la liste proposée.

git clean -i -d

Would remove the following items:
  build.log  debug.out  temp/
*** Commands ***
    1: clean                2: filter by pattern    3: select by numbers
    4: ask each             5: quit                 6: help
What now>

Choisissez 4 (ask each) pour valider fichier par fichier, ou 5 (quit) pour sortir sans rien supprimer.

Récupérer un stash perdu

Si vous avez accidentellement lancé git stash clear ou git stash drop sur un stash important, il est souvent encore récupérable grâce aux objets Git orphelins.

# Lister les objets stash non référencés dans l'historique
git fsck --unreachable | grep commit | awk '{print $3}' | while read sha; do
  git log -1 --oneline --no-walk "$sha"
done

Cela affiche les commits orphelins récents. Un stash est techniquement un commit, et son message vous permet de le repérer : WIP on <branche> quand il a été créé sans message, On <branche> : <votre message> sinon. La commande liste aussi des commits index on <branche> : ce sont les objets internes que Git crée pour mémoriser l'état de l'index, ignorez-les et ciblez les entrées WIP on ou On.

Pour inspecter et restaurer :

# Voir le contenu d'un commit orphelin
git show <sha>

# Appliquer les modifications
git stash apply <sha>

Combiner stash et clean

Pour un working directory parfaitement propre :

# D'abord, sauvegarder les modifications suivies
git stash push -u -m "backup avant nettoyage"

# Ensuite, supprimer les artefacts ignorés
git clean -fdX

# Après l'opération, récupérer le travail
git stash pop

Dépannage

Les deux premières lignes de ce tableau décrivent la même situation vue sous deux angles : un pop qui rencontre un conflit applique quand même ce qu'il peut, mais conserve l'entrée dans la pile. C'est voulu, Git préfère laisser une copie de secours plutôt que la détruire pendant que vous résolvez le conflit. Une fois le conflit réglé, à vous de faire le drop manuellement, sinon vous accumulerez des entrées fantômes que vous rappliquerez par erreur plus tard.

Symptôme	Cause probable	Solution
`CONFLICT` au `stash pop`	Le code a évolué depuis le stash	`git stash branch nom` pour appliquer sur le bon contexte
`stash pop` ne supprime pas le stash	Conflit lors de l'application	Résolvez les conflits puis `git stash drop` manuellement
`clean` ne supprime rien	Oubli de `-f`	Ajoutez `-f` (obligatoire)
`clean` supprime trop	`-x` inclut les ignorés	Utilisez `-X` pour uniquement les ignorés, ou `-e` pour exclure
Fichier non stashé	Fichier non suivi (nouveau)	Ajoutez `-u` : `git stash push -u`

À retenir

git stash sauvegarde les modifications dans une pile, parfait pour changer de contexte
-u pour inclure les fichiers non suivis, --keep-index pour garder le staging
git stash pop applique et supprime, apply applique sans supprimer
git clean -n toujours en premier (dry-run), puis -f pour exécuter
git clean -fdX : nettoyage des artefacts de build (fichiers ignorés uniquement)

FAQ : git stash

Six questions qui reviennent en permanence sur git stash, dont la première porte sur une commande qui n'existe pas : il n'y a pas de git unstash, la récupération passe par pop ou apply. Les autres réponses reprennent en format court les points du guide sur le nommage, la suppression et le stash partiel.

Comment faire un git unstash pour récupérer ses modifications ?

git unstash n'existe pas comme commande : pour récupérer un stash, utilisez git stash pop (applique le dernier stash et le supprime de la liste) ou git stash apply (applique le stash mais le conserve). C'est l'inverse de git stash, qui met les modifications de côté.

La commande git unstash n'existe pas : Git récupère un stash avec l'une de ces deux commandes :

git stash pop     # applique le dernier stash ET le retire de la liste
git stash apply   # applique le dernier stash mais le CONSERVE

Pour récupérer un stash précis (pas le dernier), donnez sa référence vue dans git stash list :

git stash pop stash@{2}

Retenez : git stash met de côté, git stash pop/apply remet.

Quelle différence entre git stash pop et git stash apply ?

git stash pop applique le stash puis le supprime de la pile : à utiliser quand vous en avez fini avec lui. git stash apply applique le stash mais le garde dans la liste, utile pour réappliquer les mêmes modifications sur plusieurs branches.

Les deux réappliquent vos modifications mises de côté, la différence est ce qu'il advient du stash :

Commande	Applique	Conserve le stash
`git stash pop`	oui	non (retiré de la pile)
`git stash apply`	oui	oui (reste dans la liste)

Utilisez pop dans le cas courant (vous en avez fini). Utilisez apply pour réappliquer le même stash sur plusieurs branches, ou par prudence si l'application peut générer un conflit (le stash reste récupérable).

Comment lister ses stash et voir leur contenu ?

git stash list affiche la pile des stash avec leur référence stash@{n}. git stash show donne un résumé des fichiers modifiés, et git stash show -p affiche le diff complet d'un stash sans l'appliquer.

Pour inventorier vos stash puis inspecter l'un d'eux sans l'appliquer :

git stash list                 # la pile : stash@{0}, stash@{1}...
git stash show stash@{1}       # résumé des fichiers touchés
git stash show -p stash@{1}    # le diff complet (patch)

Chaque stash est identifié par stash@{n}, stash@{0} étant le plus récent. Ces références servent ensuite à pop, apply ou drop un stash précis.

Comment supprimer un stash ou vider toute la pile ?

git stash drop stash@{n} supprime un stash précis, et git stash clear vide toute la pile d'un coup. Ces suppressions sont définitives : un stash supprimé n'apparaît plus dans git stash list, même s'il reste parfois récupérable via git reflog.

Deux niveaux de nettoyage :

git stash drop stash@{1}   # supprime un stash précis
git stash clear            # vide TOUTE la pile de stash

Attention : git stash clear est définitif et silencieux. Un stash supprimé par erreur reste parfois récupérable via git reflog (les entrées refs/stash), mais ne comptez pas dessus : vérifiez toujours avec git stash list avant de vider.

Comment nommer un git stash pour le retrouver ?

Utilisez git stash push -m "message" pour donner une description au stash. Le message s'affiche dans git stash list, ce qui évite de deviner à quoi correspond chaque stash@{n} quand la pile en contient plusieurs.

Par défaut, un stash porte un nom généré peu parlant (WIP on main: ...). Donnez-lui un message explicite avec la forme moderne git stash push :

git stash push -m "refonte formulaire login"

Le message apparaît alors dans git stash list :

stash@{0}: On main: refonte formulaire login

C'est indispensable dès que vous accumulez plusieurs stash : sans message, impossible de savoir lequel pop sans inspecter chaque diff.

Comment ne mettre de côté que certains fichiers avec git stash ?

git stash push suivi de chemins ne stashe que les fichiers indiqués. L'option --keep-index conserve dans le working directory ce qui est déjà indexé, et --include-untracked ajoute les fichiers non suivis au stash.

La commande git stash push accepte des chemins et des options fines :

git stash push src/login.js src/api.js   # ne stashe que ces fichiers
git stash push --keep-index              # stashe tout mais garde l'index intact
git stash push -u                        # inclut aussi les fichiers non suivis (untracked)

--keep-index est utile pour tester ce qui est indexé avant de committer : vous mettez de côté le reste, vous validez que la partie stagée fonctionne seule, puis vous récupérez le stash.

Prochaines étapes

Rechercher dans Git Trouvez du code et des commits avec git grep et git log -S.

Staging interactif Choisissez quoi committer hunk par hunk avec git add -p.

Reset démystifié Comprenez les 3 arbres et les différences soft/mixed/hard.