Parcourir les aide-mémoire · Git

Technologie: GitCatégorie: Gestion de versionsNiveau: IntermédiaireMis à jour

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
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Vérifier d’abord l’arbre de travail
  5. 2. Mettre de côté les modifications suivies
  6. 3. Inclure les fichiers non suivis
  7. 4. Comprendre ce que -u n’inclut pas
  8. 5. Donner un message utile à chaque stash
  9. 6. Lister les stashs
  10. 7. Afficher le résumé d’un stash
  11. 8. Inspecter le patch complet d’un stash
  12. 9. Appliquer un stash sans le supprimer
  13. 10. Appliquer le stash le plus récent
  14. 11. Faire un pop du stash le plus récent
  15. 12. Faire un pop d’un stash précis
  16. 13. Préférer apply pour un travail précieux
  17. 14. Supprimer un stash
  18. 15. Effacer tous les stashs uniquement de manière délibérée
  19. 16. Mettre de côté uniquement certains fichiers
  20. 17. Mettre de côté de façon interactive, bloc par bloc
  21. 18. Conserver les modifications indexées en place
  22. 19. Mettre de côté uniquement les modifications indexées
  23. 20. Afficher la version actuelle de Git
  24. 21. Créer une branche directement à partir d’un stash
  25. 22. Utiliser stash branch lorsque le contexte a beaucoup changé
  26. 23. Mettre de côté avant de changer de branche
  27. 24. Mettre de côté avant un rebase
  28. 25. Utiliser l’autostash du rebase lorsque c’est approprié
  29. 26. Mettre de côté avant un pull lorsque des modifications locales bloquent la mise à jour
  30. 27. Inspecter l’état après l’application
  31. 28. Gérer les conflits de stash apply
  32. 29. Comprendre le comportement d’apply en cas de conflit
  33. 30. Comprendre le comportement de pop en cas de conflit
  34. 31. Rechercher des conflits après un pop
  35. 32. Restaurer l’état indexé depuis un stash
  36. 33. Faire un pop en restaurant l’index
  37. 34. Inspecter le stash sous forme de commits
  38. 35. Comparer un stash avec le travail actuel
  39. 36. Comparer le contenu d’un stash avec sa base d’origine
  40. 37. Mettre de côté avec prudence un fichier partiellement indexé
  41. 38. Utiliser le mode patch pour une portée de stash précise
  42. 39. Utiliser des pathspecs pour éviter de mettre de côté des fichiers sans rapport
  43. 40. Ne pas utiliser le stash comme stockage de projet à long terme
  44. 41. Convertir un travail important mis de côté en branche
  45. 42. Préférer un commit WIP lorsque la collaboration compte
  46. 43. Se rappeler que les stashs sont locaux par défaut
  47. 44. Utiliser le stash pour de courts changements de contexte
  48. 45. Récupérer un stash supprimé récemment grâce au reflog et à l’inspection des objets
  49. 46. Ne pas lancer de garbage collection agressive pendant une récupération
  50. 47. Vérifier que l’état est propre après la mise de côté
  51. 48. Le stash ne remplace pas .gitignore
  52. 49. Le stash ne résout pas les problèmes d’organisation des branches
  53. 50. Vérifier avant de supprimer
  54. Interpréter le résultat
  55. Points à vérifier
  56. De nouveaux fichiers ont disparu après la mise de côté
  57. Le stash s’applique avec des conflits
  58. pop n’a pas supprimé le stash
  59. La répartition entre indexé et non indexé a changé après l’application
  60. Vous avez de nombreux stashs anciens
  61. Notes de production
  62. Les stashs sont un état local
  63. apply est plus sûr que pop pour un travail important
  64. Les fichiers non suivis et ignorés nécessitent des options explicites
  65. Les conflits de stash sont normaux après une divergence de branche
  66. Les stashs peuvent contenir des fichiers sensibles
  67. Le travail de longue durée a sa place sur une branche
  68. Erreurs fréquentes
  69. 1. Supposer que les fichiers non suivis sont mis de côté automatiquement
  70. 2. Utiliser pop avant d’inspecter un ancien stash
  71. 3. Effacer tous les stashs à la légère
  72. 4. Considérer le stash comme une sauvegarde durable
  73. 5. Mettre de côté des fichiers ignorés avec -a sans les vérifier
  74. 6. Supposer que l’état indexé est toujours restauré à l’identique
  75. 7. Supprimer un stash avant d’avoir testé le travail restauré
  76. 8. Laisser des stashs sans nom
  77. 9. Appliquer un stash très ancien sur une branche qui a beaucoup changé
  78. 10. Utiliser le stash pour gérer plusieurs tâches de longue durée
  79. Étape suivante
  80. 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 pop avant 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 :

  1. crée une nouvelle branche à partir du commit sur lequel le stash a été créé à l’origine
  2. applique le stash
  3. 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.

Étape suivante

Partez de la situation pour choisir la façon la plus sûre d’utiliser le stash.

  • Besoin de changer rapidement de contexte → faites un stash avec un message descriptif.
  • De nouveaux fichiers font partie du travail → ajoutez -u.
  • Des fichiers ignorés doivent aussi être déplacés → n’utilisez -a qu’après avoir évalué le risque.
  • Le travail est précieux → utilisez apply, vérifiez, puis faites un drop.
  • Besoin de l’état indexé d’origine → utilisez apply --index.
  • Le stash est ancien et produit beaucoup de conflits → utilisez git stash branch.
  • Les stashs s’accumulent → convertissez les plus importants en branches et en commits.
  • Le travail a besoin d’une sauvegarde distante → faites un commit sur une branche et un push ; ne comptez pas sur le stash.
  • Vous pensez avoir supprimé un stash par accident → interrompez tout nettoyage ou GC et examinez immédiatement le reflog et les objets inaccessibles.

← Tous les aide-mémoire