Annuler Git Stash

Une réserve Git enregistre les modifications non validées afin de vous permettre de retrouver un répertoire de travail propre. Pour restaurer le travail enregistré, choisissez entre git stash pop, qui applique la dernière réserve et supprime son entrée si l’application réussit, et git stash apply, qui l’applique tout en conservant l’entrée. Si vous souhaitez supprimer une réserve seulement après avoir vérifié les fichiers restaurés, appliquez-la d’abord, puis supprimez-la. Les exemples ci-dessous utilisent stash@{n} pour désigner une entrée précise de la liste des réserves.

Choisir la commande adaptée à votre objectif

Utilisez git stash list pour afficher les entrées enregistrées. La plus récente est généralement stash@{0}, suivie de stash@{1}, puis des entrées plus anciennes. Lisez la description des entrées avant d’en choisir une : le numéro indique sa position dans la liste actuelle et peut changer lorsqu’une entrée est ajoutée ou supprimée.

• Restaurer l’entrée la plus récente et la supprimer si son application réussit : git stash pop.
• Restaurer une entrée tout en la conservant : git stash apply.
• Supprimer une entrée sans l’appliquer : git stash drop.

Une réserve contient des modifications enregistrées du répertoire de travail, et non un nouveau commit sur votre branche. Par défaut, appliquer une réserve restaure ses modifications dans le répertoire de travail sans rétablir l’état initial de l’index ; utilisez git stash apply --index pour tenter de restaurer également l’index. Vérifiez ensuite git status pour voir ce qui a été restauré. Si vous ne savez pas si vous aurez besoin de retrouver cet état, commencez par apply ; vous pourrez supprimer l’entrée après avoir vérifié le résultat.

Exécutez cet exemple. Le code et les libellés qu’il affiche, y compris la sortie attendue, restent en anglais :

import subprocess
import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as temp_dir:
    repo = Path(temp_dir)

    def git(*args):
        subprocess.run(
            ["git", *args], cwd=repo, check=True,
            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
        )

    git("init", "-q")
    git("config", "user.name", "Example User")
    git("config", "user.email", "example@example.com")
    note = repo / "note.txt"
    note.write_text("original\n", encoding="utf-8")
    git("add", "note.txt")
    git("commit", "-q", "-m", "Add note")
    note.write_text("restored change\n", encoding="utf-8")
    git("stash", "push", "-m", "demo", "-q")
    git("stash", "pop", "-q")
    print(note.read_text(encoding="utf-8").strip())

Résultat attendu (la sortie affichée reste en anglais) :

restored change

Restaurer et supprimer la dernière réserve avec git stash pop

Pour restaurer les dernières modifications enregistrées et supprimer l’entrée correspondante, exécutez git stash pop. Git applique l’entrée en tête de liste, généralement stash@{0}. Si l’application réussit, Git supprime cette entrée. Les fichiers restaurés restent dans votre répertoire de travail : supprimer l’entrée de la réserve ne supprime pas les modifications appliquées.

Avant d’utiliser pop, vérifiez que le répertoire de travail actuel est prêt à recevoir les modifications enregistrées. Ensuite, consultez git status et examinez les fichiers concernés. Si les modifications ne semblent pas avoir été restaurées comme prévu, utilisez git stash list pour vérifier si l’entrée est toujours présente. En général, si une réserve ne peut pas être appliquée proprement, Git la conserve afin que vous puissiez résoudre le conflit et réessayer sans perdre la copie enregistrée.

Restaurer une réserve tout en la conservant avec git stash apply

Utilisez git stash apply pour récupérer les modifications tout en conservant l’entrée enregistrée. Pour appliquer la dernière entrée, exécutez git stash apply. Pour choisir une entrée plus ancienne, ajoutez son sélecteur, par exemple git stash apply stash@{2}. Cette méthode est utile si vous souhaitez comparer le résultat ou si vous pourriez avoir besoin de restaurer le même travail enregistré dans un autre répertoire de travail plus tard.

Après l’application, consultez git status et examinez les fichiers avant de poursuivre vos modifications. L’application d’une réserve ne la supprime pas, que le résultat soit propre ou nécessite la résolution de conflits. Une fois les modifications restaurées vérifiées et le travail terminé, supprimez l’entrée avec git stash drop si vous n’en avez plus besoin, comme indiqué ci-dessous.

Supprimer une réserve après l’avoir restaurée avec git stash drop

git stash drop supprime une entrée de la liste des réserves sans l’appliquer. Utilisez cette commande uniquement si vous souhaitez supprimer cette copie enregistrée. Sans sélecteur, elle supprime l’entrée la plus récente. Pour viser une entrée précise, indiquez son sélecteur, par exemple git stash drop stash@{2}.

Pour restaurer puis supprimer une réserve avec prudence, exécutez d’abord git stash apply avec le sélecteur voulu, puis examinez les fichiers et consultez git status. Si les modifications ont bien été restaurées et que vous n’avez plus besoin de la copie enregistrée, exécutez git stash drop avec ce même sélecteur. Juste avant de supprimer l’entrée, vérifiez git stash list : la suppression d’une entrée antérieure peut modifier les numéros attribués aux entrées restantes. Si vous exécutez plutôt git stash pop, Git combine l’application et la suppression lorsque l’application réussit.

Choisir une réserve et résoudre les conflits

Affichez les entrées avec git stash list, puis sélectionnez la stash@{n} voulue. Avant de l’appliquer, vous pouvez examiner le correctif enregistré avec git stash show -p stash@{2}, en remplaçant 2 par le numéro indiqué dans la liste. Les descriptions des entrées et leur correctif peuvent aider à distinguer des réserves similaires, mais vérifiez toujours le sélecteur dans la liste actuelle avant d’agir.

Une réserve peut entrer en conflit avec des modifications présentes sur la branche actuelle. Dans ce cas, Git signale les fichiers concernés et y laisse des marqueurs de conflit à résoudre. Ouvrez chaque fichier signalé, choisissez et combinez les modifications voulues, supprimez les marqueurs de conflit, puis consultez git status et examinez le diff obtenu. Effectuez les vérifications habituelles du projet avant de considérer la restauration comme terminée. Ne supposez pas que pop a supprimé l’entrée après un conflit : Git conserve une réserve qui n’a pas pu être appliquée proprement. Une fois le répertoire de travail corrigé et le résultat vérifié, consultez git stash list, puis supprimez l’entrée conservée uniquement si vous n’en avez plus besoin.