Qu'est-ce que git stash et quand l'utilise-t-on ?

Question

Accepted Answer

**git stash** **sauvegarde temporairement vos modifications non validées** et rétablit votre répertoire de travail à un état propre — pour que vous puissiez changer de contexte (par exemple corriger un bug urgent sur une autre branche) sans valider un travail inachevé, puis restaurer les modifications plus tard.

## Le problème que stash résout

```text
You're mid-work with uncommitted changes, but need to switch context urgently:
  → switch branches? Git may refuse (uncommitted changes would conflict) or carry
    them along messily
  → commit half-done work? No — it's not ready (pollutes history)
→ STASH saves your changes aside, giving you a clean working directory to switch.
```

## Utiliser stash

```bash
git stash                      # save uncommitted changes; working dir becomes clean
git stash push -m "message"    # stash with a description
git stash list                 # list stashes (stash@{0}, stash@{1}, ...)

git stash pop                  # RESTORE the latest stash AND remove it from the list
git stash apply                # restore but KEEP it in the stash list
git stash apply stash@{1}      # apply a specific stash
git stash drop stash@{0}       # delete a stash
git stash clear                # remove all stashes
```

`git stash` sauvegarde les modifications et nettoie le répertoire de travail ; `git stash pop` les restaure plus tard (et supprime la stash). `apply` restaure sans supprimer.

## Scénario courant

```bash
# working on a feature, but an urgent bug needs fixing on main:
git stash                      # save the in-progress feature work
git switch main
# ... fix the urgent bug, commit, push ...
git switch feature
git stash pop                  # restore the feature work and continue
```

## Options utiles

```text
git stash -u        → also stash UNTRACKED files (not just tracked changes)
git stash show -p   → see what's in a stash
→ Stash is for TEMPORARY storage — not a substitute for commits/branches long-term.
```

## Pourquoi c'est important

Comprendre `git stash` est précieux pour **gérer les changements de contexte proprement**, une situation courante dans le monde réel, donc c'est une connaissance pratique et utile de Git.

Le problème qu'il résout est fréquent : vous êtes au milieu d'un travail avec des modifications non validées quand vous devez **changer de contexte d'urgence** (corriger un bug en production sur une autre branche, examiner le code de quelqu'un, récupérer des mises à jour) — mais basculer vers une autre branche avec des modifications non validées est problématique (Git peut refuser ou les transporter de manière désordonnée), et valider un travail inachevé pollue l'historique. **Stash** résout cela élégamment en **mettant vos modifications de côté** et en vous donnant un répertoire de travail propre pour changer de contexte, puis en **restaurant les modifications plus tard** quand vous revenez — s'adaptant exactement au scénario courant « Je dois suspendre momentanément ce que je fais ».

Comprendre les commandes fondamentales (`git stash` pour sauvegarder, `git stash pop` pour restaurer-et-supprimer, `git stash apply` pour restaurer-et-garder, `git stash list` pour voir les stashes) et le flux de travail typique (stasher le travail en cours, changer et gérer la tâche urgente, revenir et pop) est une connaissance pratique et quotidienne pour gérer les interruptions.

Connaître les options utiles (`-u` pour inclure les fichiers non suivis, afficher le contenu de stash) et que stash est un stockage **temporaire** (et non un substitut à long terme pour les commits/branches) reflète une utilisation appropriée.

Puisque les changements de contexte et les interruptions sont courants en développement (bugs urgents, examens, besoin d'un répertoire de travail propre), et puisque stash fournit un moyen propre et commode de mettre temporairement de côté un travail non validé et de le restaurer plus tard, comprendre `git stash` — ce qu'il résout, les commandes, et le flux de travail courant de changement de contexte — est une connaissance Git précieuse et pratiquement pertinente pour gérer le besoin fréquent et réel de changer de contexte sans valider un travail inachevé, un outil pratique qui lisse les interruptions courantes du développement quotidien.