Parcourir les aide-mémoire · Git
Git stash : mettre des modifications de côté
Utilisez git stash en toute sécurité pour mettre de côté un travail inachevé, changer de contexte, inspecter et restaurer les modifications remisées, gérer les fichiers non suivis et vous en sortir lorsque l’application d’un stash provoque des conflits.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Vérifier d’abord l’arbre de travail
- 2. Mettre de côté les modifications suivies
- 3. Inclure les fichiers non suivis
- 4. Comprendre ce que -u n’inclut pas
- 5. Donner un message utile à chaque stash
- 6. Lister les stashs
- 7. Afficher le résumé d’un stash
- 8. Inspecter le patch complet d’un stash
- 9. Appliquer un stash sans le supprimer
- 10. Appliquer le stash le plus récent
- 11. Faire un pop du stash le plus récent
- 12. Faire un pop d’un stash précis
- 13. Préférer apply pour un travail précieux
- 14. Supprimer un stash
- 15. Effacer tous les stashs uniquement de manière délibérée
- 16. Mettre de côté uniquement certains fichiers
- 17. Mettre de côté de façon interactive, bloc par bloc
- 18. Conserver les modifications indexées en place
- 19. Mettre de côté uniquement les modifications indexées
- 20. Afficher la version actuelle de Git
- 21. Créer une branche directement à partir d’un stash
- 22. Utiliser stash branch lorsque le contexte a beaucoup changé
- 23. Mettre de côté avant de changer de branche
- 24. Mettre de côté avant un rebase
- 25. Utiliser l’autostash du rebase lorsque c’est approprié
- 26. Mettre de côté avant un pull lorsque des modifications locales bloquent la mise à jour
- 27. Inspecter l’état après l’application
- 28. Gérer les conflits de stash apply
- 29. Comprendre le comportement d’apply en cas de conflit
- 30. Comprendre le comportement de pop en cas de conflit
- 31. Rechercher des conflits après un pop
- 32. Restaurer l’état indexé depuis un stash
- 33. Faire un pop en restaurant l’index
- 34. Inspecter le stash sous forme de commits
- 35. Comparer un stash avec le travail actuel
- 36. Comparer le contenu d’un stash avec sa base d’origine
- 37. Mettre de côté avec prudence un fichier partiellement indexé
- 38. Utiliser le mode patch pour une portée de stash précise
- 39. Utiliser des pathspecs pour éviter de mettre de côté des fichiers sans rapport
- 40. Ne pas utiliser le stash comme stockage de projet à long terme
- 41. Convertir un travail important mis de côté en branche
- 42. Préférer un commit WIP lorsque la collaboration compte
- 43. Se rappeler que les stashs sont locaux par défaut
- 44. Utiliser le stash pour de courts changements de contexte
- 45. Récupérer un stash supprimé récemment grâce au reflog et à l’inspection des objets
- 46. Ne pas lancer de garbage collection agressive pendant une récupération
- 47. Vérifier que l’état est propre après la mise de côté
- 48. Le stash ne remplace pas .gitignore
- 49. Le stash ne résout pas les problèmes d’organisation des branches
- 50. Vérifier avant de supprimer
- Interpréter le résultat
- Points à vérifier
- De nouveaux fichiers ont disparu après la mise de côté
- Le stash s’applique avec des conflits
- pop n’a pas supprimé le stash
- La répartition entre indexé et non indexé a changé après l’application
- Vous avez de nombreux stashs anciens
- Notes de production
- Les stashs sont un état local
- apply est plus sûr que pop pour un travail important
- Les fichiers non suivis et ignorés nécessitent des options explicites
- Les conflits de stash sont normaux après une divergence de branche
- Les stashs peuvent contenir des fichiers sensibles
- Le travail de longue durée a sa place sur une branche
- Erreurs fréquentes
- 1. Supposer que les fichiers non suivis sont mis de côté automatiquement
- 2. Utiliser pop avant d’inspecter un ancien stash
- 3. Effacer tous les stashs à la légère
- 4. Considérer le stash comme une sauvegarde durable
- 5. Mettre de côté des fichiers ignorés avec -a sans les vérifier
- 6. Supposer que l’état indexé est toujours restauré à l’identique
- 7. Supprimer un stash avant d’avoir testé le travail restauré
- 8. Laisser des stashs sans nom
- 9. Appliquer un stash très ancien sur une branche qui a beaucoup changé
- 10. Utiliser le stash pour gérer plusieurs tâches de longue durée
- Étape suivante
- Pour aller plus loin
Problème
Vous avez un travail local inachevé, mais vous devez :
- changer de branche
- faire un pull ou un rebase
- tester une autre modification
- traiter un correctif urgent
- nettoyer temporairement l’arbre de travail
- conserver des modifications sans créer de commit permanent
git stash peut vous aider, mais une utilisation négligente pose des problèmes :
- oublier ce que contient un stash
- perdre le fil lorsqu’il y a plusieurs stashs
- supposer que les fichiers non suivis sont inclus automatiquement
- utiliser
popavant d’inspecter - créer des conflits lors de la restauration
- utiliser le stash comme stockage à long terme
- effacer des stashs par accident
L’objectif est d’utiliser le stash comme un outil de sécurité temporaire et inspectable, et non comme un substitut aux branches ou aux commits.
Réponse rapide
Mettre de côté les modifications suivies :
git stash push -m "WIP report engine"
Inclure les fichiers non suivis :
git stash push -u -m "WIP report engine"
Lister les stashs :
git stash list
Inspecter avant de restaurer :
git stash show -p stash@{0}
Appliquer sans supprimer :
git stash apply stash@{0}
Supprimer uniquement après avoir confirmé que le travail est restauré :
git stash drop stash@{0}
N’utilisez pop que si vous êtes à l’aise avec le fait d’appliquer et de supprimer le stash en une seule étape :
git stash pop
Code / commandes
1. Vérifier d’abord l’arbre de travail
git status
Sachez ce qui va être mis de côté avant de lancer la commande.
Selon les options, un stash peut inclure des ensembles de modifications différents.
2. Mettre de côté les modifications suivies
git stash push -m "WIP report engine"
Par défaut, cette commande met de côté les modifications suivies, qu’elles soient indexées (placées dans l’index, ou zone de préparation) ou non.
L’arbre de travail est ramené vers l’état de HEAD.
3. Inclure les fichiers non suivis
git stash push -u -m "WIP report engine"
-u / --include-untracked inclut les fichiers non suivis.
Utilisez cette option lorsque de nouveaux fichiers font partie du travail inachevé.
4. Comprendre ce que -u n’inclut pas
Les fichiers ignorés ne sont pas inclus par -u.
Si vous avez réellement besoin des fichiers ignorés aussi :
git stash push -a -m "WIP including ignored files"
-a / --all inclut les fichiers ignorés.
À utiliser avec prudence, car les fichiers ignorés comprennent souvent :
- des artefacts de build
- des caches
- des fichiers d’environnement locaux
- des données générées
5. Donner un message utile à chaque stash
Préférez :
git stash push -m "WIP Fabric pipeline retry changes"
à :
git stash
Des messages explicites deviennent importants dès qu’il existe plusieurs stashs.
6. Lister les stashs
git stash list
Exemple :
stash@{0}: On feature/report-engine: WIP retry logic
stash@{1}: On main: WIP README update
Le stash le plus récent est généralement stash@{0}.
7. Afficher le résumé d’un stash
git stash show stash@{0}
Cette commande affiche un résumé de type diffstat.
8. Inspecter le patch complet d’un stash
git stash show -p stash@{0}
Faites-le avant de restaurer un stash ancien ou que vous ne connaissez pas bien.
9. Appliquer un stash sans le supprimer
git stash apply stash@{0}
Utilisez cette commande lorsque vous voulez conserver le stash jusqu’à ce que vous ayez vérifié le travail restauré.
C’est plus sûr que pop pour des modifications importantes.
10. Appliquer le stash le plus récent
git stash apply
Équivaut à appliquer le stash le plus récent.
Lorsqu’il existe plusieurs stashs, indiquer le stash exact est plus clair.
11. Faire un pop du stash le plus récent
git stash pop
Cette commande applique le stash le plus récent et, si l’application réussit sans problème, supprime cette entrée de stash.
À utiliser lorsque vous êtes sûr que la restauration est simple.
12. Faire un pop d’un stash précis
git stash pop stash@{1}
Utile lorsque le stash voulu n’est pas le plus récent.
13. Préférer apply pour un travail précieux
Procédure de récupération plus sûre :
git stash apply stash@{0}
git status
git diff
Après vérification :
git stash drop stash@{0}
Vous gardez ainsi une sauvegarde jusqu’à ce que vous ayez confirmé que le travail est correctement restauré.
14. Supprimer un stash
git stash drop stash@{0}
Cette commande supprime cette référence de stash.
Inspectez-le d’abord au moindre doute.
15. Effacer tous les stashs uniquement de manière délibérée
git stash clear
Cette commande supprime toutes les entrées de stash.
Ne l’utilisez pas comme nettoyage de routine.
Il n’y a pas de confirmation habituelle entrée par entrée.
16. Mettre de côté uniquement certains fichiers
git stash push \
-m "WIP API changes" \
-- src/api.py src/config.py
Les modifications sans rapport restent en place dans l’arbre de travail.
Utilisez des pathspecs lorsque seule une partie du travail doit être mise de côté.
17. Mettre de côté de façon interactive, bloc par bloc
git stash push -p
Git vous interroge pour chaque bloc (hunk).
Utilisez cette option lorsqu’un même fichier contient :
- du travail que vous voulez mettre de côté
- du travail que vous voulez garder actif
18. Conserver les modifications indexées en place
Si votre version de Git le prend en charge :
git stash push --keep-index
Cette commande met de côté les autres modifications tout en laissant les modifications indexées dans l’index.
Utile lorsque vous voulez tester le commit préparé de manière indépendante.
19. Mettre de côté uniquement les modifications indexées
Sur les versions récentes de Git :
git stash push --staged
Cette commande met de côté le contenu indexé et laisse les modifications non indexées dans l’arbre de travail.
Vérifiez votre version de Git si cette option n’est pas disponible.
20. Afficher la version actuelle de Git
git --version
Utile lorsque les options de stash diffèrent sur des installations de Git plus anciennes.
21. Créer une branche directement à partir d’un stash
git stash branch recovery-work stash@{0}
Cette commande :
- crée une nouvelle branche à partir du commit sur lequel le stash a été créé à l’origine
- applique le stash
- le supprime si l’application réussit
Utilisez-la lorsque la branche actuelle a divergé et que l’application directe du stash produit des conflits.
22. Utiliser stash branch lorsque le contexte a beaucoup changé
Exemple de situation :
stash créé il y a deux semaines
main a beaucoup changé
la branche de fonctionnalité a beaucoup changé
Au lieu de l’appliquer sur la branche actuelle :
git stash branch old-wip stash@{2}
Cela donne souvent à Git une base plus compatible.
23. Mettre de côté avant de changer de branche
git stash push -u -m "WIP before hotfix"
git switch hotfix/production
Après le correctif :
git switch feature/report-engine
git stash apply stash@{0}
Utilisez des messages explicites pour que le stash reste facile à identifier.
24. Mettre de côté avant un rebase
git stash push -u -m "WIP before rebase"
git fetch origin
git rebase origin/main
git stash apply stash@{0}
Un arbre de travail propre rend le rebase plus facile à comprendre.
25. Utiliser l’autostash du rebase lorsque c’est approprié
git rebase --autostash origin/main
Git crée automatiquement un stash temporaire et le réapplique à la fin.
C’est pratique, mais des conflits peuvent tout de même survenir lors de la restauration du stash temporaire.
Un stash manuel est souvent plus facile à inspecter et à contrôler.
26. Mettre de côté avant un pull lorsque des modifications locales bloquent la mise à jour
Si le workflow de l’équipe impose pull/rebase :
git stash push -u -m "WIP before sync"
git pull --ff-only
ou :
git fetch origin
git rebase origin/main
Restaurez ensuite le stash.
Ne mettez pas de côté automatiquement sans vérifier si ces modifications ne devraient pas plutôt faire l’objet d’un commit au préalable.
27. Inspecter l’état après l’application
git status
Puis :
git diff
git diff --cached
Ne supposez pas que l’application du stash a restauré exactement ce que vous attendiez.
28. Gérer les conflits de stash apply
Si l’application provoque des conflits :
git status
Git signale les fichiers en conflit.
Résolvez-les manuellement, puis :
git add path/to/file
Contrairement au rebase, il n’existe pas de :
git stash --continue
Vous résolvez l’arbre de travail normalement.
29. Comprendre le comportement d’apply en cas de conflit
Si :
git stash apply stash@{0}
provoque des conflits, l’entrée de stash est conservée.
C’est utile, car le stash d’origine existe toujours pendant que vous résolvez l’arbre de travail.
30. Comprendre le comportement de pop en cas de conflit
Si git stash pop rencontre des conflits, Git conserve généralement le stash au lieu de le supprimer.
Vérifiez tout de même avec :
git stash list
Ne supposez pas que le stash a été supprimé.
31. Rechercher des conflits après un pop
git status
Puis :
git stash list
Confirmez à la fois l’état de l’arbre de travail et la présence éventuelle de l’entrée de stash.
32. Restaurer l’état indexé depuis un stash
Par défaut, l’application d’un stash restaure les modifications des fichiers, mais ne recrée pas forcément exactement la répartition entre modifications indexées et non indexées.
Utilisez :
git stash apply --index stash@{0}
pour tenter de restaurer aussi l’état indexé.
Cela peut échouer si l’index ne peut pas être appliqué proprement.
33. Faire un pop en restaurant l’index
git stash pop --index
À utiliser uniquement lorsque la restauration de l’état d’origine de la zone de préparation compte.
Pour un travail précieux, préférez d’abord apply --index.
34. Inspecter le stash sous forme de commits
En interne, un stash est représenté à l’aide de commits Git.
Vous pouvez l’inspecter :
git show stash@{0}
ou :
git log -g --oneline refs/stash
Vous n’avez normalement pas besoin de la structure interne, mais savoir que le stash repose sur des objets Git aide à comprendre pourquoi une récupération à partir du reflog peut parfois fonctionner.
35. Comparer un stash avec le travail actuel
git diff stash@{0}
Pour un fichier précis :
git diff stash@{0} -- src/app.py
Faites-le avant d’appliquer si le code actuel a beaucoup évolué.
36. Comparer le contenu d’un stash avec sa base d’origine
git stash show -p stash@{0}
C’est généralement la façon la plus claire de voir ce que le stash a introduit.
37. Mettre de côté avec prudence un fichier partiellement indexé
Un fichier peut contenir :
modifications indexées
+
modifications non indexées
Avant de les mettre de côté, inspectez les deux :
git diff --cached
git diff
Décidez ensuite si vous avez besoin :
- d’un stash normal
- de
--keep-index - de
--staged - du mode patch
Ne supposez pas que la frontière entre indexé et non indexé se comportera comme vous le souhaitez.
38. Utiliser le mode patch pour une portée de stash précise
git stash push -p -m "Only experimental changes"
Utilisez-le lorsque vous avez besoin d’un contrôle bloc par bloc.
Examinez attentivement chaque bloc.
39. Utiliser des pathspecs pour éviter de mettre de côté des fichiers sans rapport
git stash push \
-m "WIP backend only" \
-- src/api src/services
C’est utile dans les dépôts où plusieurs tâches sans rapport sont menées en même temps.
Mieux encore, envisagez des branches ou des worktrees séparés si ce schéma est fréquent.
40. Ne pas utiliser le stash comme stockage de projet à long terme
Mauvaise pratique :
stash@{0} vieux de 3 mois
stash@{1} vieux de 4 mois
stash@{2} "WIP"
stash@{3} "stuff"
Si le travail compte, préférez :
branche temporaire
+
commits normaux
Les branches sont plus faciles à :
- relire
- pousser (push)
- sauvegarder
- partager
- récupérer
41. Convertir un travail important mis de côté en branche
git stash branch feature/recovered-work stash@{0}
Faites ensuite des commits normalement.
Cela transforme un état temporaire en historique durable.
42. Préférer un commit WIP lorsque la collaboration compte
Au lieu de mettre de côté un travail important :
git add -A
git commit -m "WIP: report engine changes"
sur une branche de fonctionnalité privée peut être plus sûr, car le travail peut être poussé sur le dépôt distant.
Nettoyez ensuite l’historique avec un rebase interactif si nécessaire.
Ne poussez pas de commits WIP sur des branches protégées ou partagées, sauf si la politique de l’équipe l’autorise.
43. Se rappeler que les stashs sont locaux par défaut
Un stash n’est pas poussé automatiquement vers GitHub, GitLab, Azure DevOps ou un autre dépôt distant.
Si votre ordinateur portable disparaît, un stash non poussé peut disparaître avec lui.
Un travail important doit devenir un commit sur une branche.
44. Utiliser le stash pour de courts changements de contexte
Bons exemples :
correctif urgent
comparaison rapide de branches
nettoyage temporaire pour un rebase
test sur un arbre de travail propre
Mauvais usage :
stocker indéfiniment une semaine de fonctionnalité inachevée
45. Récupérer un stash supprimé récemment grâce au reflog et à l’inspection des objets
Commencez par :
git reflog --all
et :
git fsck --no-reflogs --unreachable
La récupération n’est pas garantie et devient plus difficile après le ramasse-miettes (garbage collection).
Ne comptez pas sur cette méthode comme procédure normale.
Mieux vaut prévenir : inspectez avant de supprimer et utilisez des branches pour un travail important.
46. Ne pas lancer de garbage collection agressive pendant une récupération
Si vous essayez de récupérer un stash supprimé, évitez les commandes susceptibles d’élaguer les objets inaccessibles.
Créez une référence de récupération dès que vous avez identifié le commit concerné.
47. Vérifier que l’état est propre après la mise de côté
Après :
git stash push -u -m "WIP"
lancez :
git status
Confirmez que l’arbre de travail est réellement assez propre pour l’opération suivante.
Des fichiers ignorés peuvent encore subsister.
48. Le stash ne remplace pas .gitignore
Si des fichiers générés gênent régulièrement les opérations sur les branches, corrigez les règles d’exclusion du dépôt lorsque c’est pertinent.
Ne mettez pas de côté ou ne nettoyez pas de façon répétée des fichiers qui ne devraient jamais être versionnés.
49. Le stash ne résout pas les problèmes d’organisation des branches
Si vous faites constamment des stashs parce que vous menez plusieurs tâches en parallèle dans un seul répertoire de travail, envisagez :
- des branches de fonctionnalité séparées
git worktree- des tâches au périmètre plus réduit
Le stash sert à déplacer temporairement du travail, pas à structurer un multitâche permanent.
50. Vérifier avant de supprimer
Une séquence sûre :
git stash apply stash@{0}
git status
git diff
# run tests if relevant
git stash drop stash@{0}
Ne supprimez pas la sauvegarde tant que l’état restauré n’est pas confirmé comme correct.
Interpréter le résultat
| Commande | Ce qu’elle fait |
|---|---|
git stash push |
Met temporairement de côté les modifications suivies, indexées ou non |
git stash push -u |
Inclut aussi les fichiers non suivis |
git stash push -a |
Inclut aussi les fichiers ignorés |
git stash list |
Liste les entrées de stash |
git stash show -p |
Affiche le patch du stash |
git stash apply |
Restaure le stash mais conserve l’entrée de stash |
git stash pop |
Restaure le stash et supprime normalement l’entrée en cas de succès |
git stash apply --index |
Tente de restaurer aussi l’état indexé |
git stash drop |
Supprime une entrée de stash |
git stash clear |
Supprime toutes les entrées de stash |
git stash branch |
Crée une branche à partir de la base d’origine du stash et l’y applique |
La procédure de restauration la plus sûre est :
inspecter
→ apply
→ vérifier
→ drop
Points à vérifier
De nouveaux fichiers ont disparu après la mise de côté
Vous avez probablement utilisé :
git stash push
sans :
-u
Les fichiers non suivis ne sont pas inclus par défaut.
Le stash s’applique avec des conflits
La branche cible a changé depuis la création du stash.
Utilisez :
git status
résolvez manuellement, ou envisagez :
git stash branch
à partir de la base d’origine du stash.
pop n’a pas supprimé le stash
Vérifiez :
git stash list
Un conflit a peut-être amené Git à le conserver.
La répartition entre indexé et non indexé a changé après l’application
Utilisez :
git stash apply --index
lorsque la préservation de l’état de l’index compte.
Vous avez de nombreux stashs anciens
Un travail important est stocké au mauvais endroit.
Convertissez les stashs utiles en branches et en commits, et supprimez délibérément ceux qui sont obsolètes.
Notes de production
Les stashs sont un état local
Ils ne remplacent pas une sauvegarde sur un dépôt distant.
Si le travail compte, faites-en un commit sur une branche et poussez-la lorsque c’est approprié.
apply est plus sûr que pop pour un travail important
apply laisse le stash disponible jusqu’à la vérification.
Vous disposez ainsi d’une solution de repli si la résolution des conflits ou l’état restauré est incorrect.
Les fichiers non suivis et ignorés nécessitent des options explicites
Utilisez :
-u
pour les fichiers non suivis.
Utilisez :
-a
uniquement lorsque les fichiers ignorés doivent vraiment être inclus.
Les conflits de stash sont normaux après une divergence de branche
Un stash est un instantané semblable à un patch, pris sur un état antérieur du dépôt.
Plus il reste longtemps, plus les conflits à l’application deviennent probables.
Les stashs peuvent contenir des fichiers sensibles
L’option -a peut mettre de côté une configuration locale ignorée ou des fichiers contenant des secrets.
Ils restent des objets Git locaux.
Évitez d’inclure des secrets sans nécessité.
Le travail de longue durée a sa place sur une branche
Les branches et les commits offrent une récupération plus claire, un historique, une intégration à la CI et une sauvegarde distante.
Erreurs fréquentes
1. Supposer que les fichiers non suivis sont mis de côté automatiquement
Utilisez -u lorsque de nouveaux fichiers doivent être inclus.
2. Utiliser pop avant d’inspecter un ancien stash
Préférez show + apply pour un travail important.
3. Effacer tous les stashs à la légère
git stash clear supprime toutes les entrées de stash.
4. Considérer le stash comme une sauvegarde durable
Les stashs sont locaux et faciles à oublier ou à supprimer.
5. Mettre de côté des fichiers ignorés avec -a sans les vérifier
Vous risquez d’inclure des secrets locaux ou d’énormes répertoires générés.
6. Supposer que l’état indexé est toujours restauré à l’identique
Utilisez --index lorsque c’est important.
7. Supprimer un stash avant d’avoir testé le travail restauré
Gardez la sauvegarde jusqu’à la fin de la vérification.
8. Laisser des stashs sans nom
Plusieurs entrées nommées « WIP » deviennent difficiles à distinguer.
9. Appliquer un stash très ancien sur une branche qui a beaucoup changé
Utilisez git stash branch si l’application directe produit beaucoup de conflits.
10. Utiliser le stash pour gérer plusieurs tâches de longue durée
Utilisez plutôt des branches ou des worktrees.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.