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

# 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`

Option	Effet
`-m "message"`	Ajoute un message descriptif
`--keep-index`	Stashe les modifications non stagées uniquement — le staging area reste intact
`--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

# 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

# Voir ce qui serait supprimé (sans rien faire)
git clean -n
# Would remove build.log
# Would remove temp/

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

Options de `git clean`

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

git clean -i

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

Choisissez 4 (ask each one) pour valider fichier par fichier.

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 — son message commence généralement par WIP 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

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)

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.