Arbre de décision : que veux-tu annuler ?
La bonne commande Git pour annuler dépend de l'emplacement de tes modifications dans le workflow Git. Pose-toi trois questions : est-ce commité ? Est-ce pushé ? Est-ce indexé ? La réponse t'oriente vers la bonne commande.
Fichiers modifiés dans le répertoire de travail
Tu as modifié des fichiers mais tu n'as pas encore lancé git add.
Utilise git restore ou git clean
Fichiers ajoutés à la zone d'indexation
Tu as lancé git add mais tu n'as pas encore commité.
Utilise git restore --staged
Commits locaux uniquement
Tu as commité mais les modifications sont encore sur ta machine.
Utilise git reset
Modifications partagées avec l'équipe
Le commit est sur le dépôt distant. Réécrire l'historique causerait des problèmes.
Utilise git revert
Mettre de côté temporairement
Tu veux mettre de côté ton travail en cours et y revenir plus tard.
Utilise git stash
Récupérer après une opération destructive
Tu as lancé reset --hard ou supprimé une branche et tu dois récupérer.
Utilise git reflog
Annuler des modifications non commitées
Ces commandes agissent sur ton répertoire de travail : les fichiers que tu as modifiés mais pas encore commités. C'est le scénario d'annulation le plus simple : tu as changé quelque chose et tu veux revenir à la dernière version commitée.
git restore — Annuler les modifications d'un fichier
git restore <fichier> remet un fichier dans son dernier état commité. Toutes les modifications non commitées de ce fichier sont supprimées. Utilise git restore . pour annuler toutes les modifications de tous les fichiers d'un coup. C'est le remplacement moderne de git checkout -- <fichier>.
Attention : cette opération est irréversible. Une fois le fichier restauré, les modifications supprimées sont perdues : elles n'avaient jamais été commitées, donc Git n'en a aucune trace.
git clean — Supprimer les fichiers non suivis
git restore ne fonctionne que sur les fichiers suivis. Pour les fichiers non suivis (nouveaux fichiers que Git ne connaît pas), tu as besoin de git clean. Le flag -n effectue un essai à blanc pour prévisualiser ce qui serait supprimé. Le flag -f supprime réellement les fichiers, et -d inclut les répertoires.
Lance toujours git clean -n d'abord. Comme git restore, cette commande est irréversible pour les fichiers non suivis : ils n'ont jamais été commités.
Annuler des modifications indexées
Tu as lancé git add et un fichier se trouve maintenant dans la zone d'indexation, prêt à être commité. Mais tu as changé d'avis : tu veux le désindexer sans perdre tes modifications.
git restore --staged — Désindexer sans perdre les modifications
git restore --staged <fichier> retire un fichier de la zone d'indexation et le remet à l'état "modifié mais non indexé". Tes modifications dans le fichier sont conservées : seule l'indexation est annulée. C'est le remplacement moderne de git reset HEAD <fichier>.
Tu peux aussi combiner les deux flags : git restore --staged --worktree <fichier> désindexe le fichier et supprime les modifications en une seule opération.
Annuler des commits locaux
Tu as commité mais pas encore pushé. Comme le commit n'existe que sur ta machine, tu peux réécrire l'historique en toute sécurité sans affecter personne d'autre. L'outil pour cela est git reset.
git reset — Déplacer HEAD en arrière
git reset déplace le pointeur de branche (HEAD) vers un commit précédent. Ce qui arrive aux fichiers dépend du mode choisi :
--soft: annule le commit. Les modifications restent indexées (dans l'index). A utiliser quand tu veux modifier ou découper un commit.--mixed(défaut) : annule le commit et l'indexation. Les modifications restent dans ton répertoire de travail. A utiliser pour resélectionner les fichiers à inclure.--hard— Annule tout : commit, indexation et modifications du répertoire de travail. A utiliser avec une extrême prudence : c'est destructif.
git reset --soft : garder les modifications indexées
git reset --mixed : garder les modifications non indexées
git reset --hard : tout supprimer
Annuler des commits pushés
Une fois qu'un commit a été pushé, il est partagé avec l'équipe. Réécrire l'historique avec git reset causerait des problèmes à toutes les personnes ayant déjà fait un pull. L'approche sûre est git revert.
git revert — Créer un commit inverse
git revert <hash> crée un nouveau commit qui fait exactement l'inverse du commit spécifié. Si le commit original a ajouté une ligne, le revert la supprime. S'il a supprimé un fichier, le revert le restaure. Le commit original reste dans l'historique : rien n'est réécrit.
C'est la seule méthode sûre pour annuler un commit sur une branche partagée. Après le revert, tu pushes simplement le nouveau commit et tes collègues le récupèrent sans conflits.
Sauvegarder temporairement son travail
Parfois, tu ne veux pas annuler tes modifications, mais les mettre de côté un moment. Peut-être dois-tu changer de branche pour un correctif urgent, ou tu veux un répertoire de travail propre sans perdre ta progression.
git stash — Mettre de côté pour plus tard
git stash prend toutes tes modifications non commitées (indexées et non indexées) et les sauvegarde dans une pile. Ton répertoire de travail redevient propre. Plus tard, git stash pop restaure le dernier stash et le retire de la pile. Utilise git stash apply à la place si tu veux conserver le stash pour le réutiliser.
Astuce utile : git stash -u inclut les fichiers non suivis dans le stash. Et git stash list affiche tous les stashes sauvegardés pour gérer plusieurs contextes de travail en cours.
Récupérer des commits perdus
Tu as lancé git reset --hard par accident ? Supprimé une branche ? Pas de panique. Si les commits ont existé, Git les conserve encore, pendant au moins 90 jours. L'outil pour les retrouver est git reflog.
git reflog — Le filet de sécurité de Git
git reflog affiche un journal chronologique de chaque position où HEAD s'est trouvé : commits, resets, checkouts, rebases, tout. Même si un commit n'apparaît plus dans git log, il sera dans le reflog. Trouve le hash dont tu as besoin et fais un reset ou un cherry-pick pour le récupérer.
Pense au reflog comme à l'historique d'annulation de Git. Il ne suit pas les modifications au niveau des fichiers, mais les positions successives de HEAD. C'est le filet de sécurité ultime pour récupérer de pratiquement n'importe quelle erreur.
Voilà qui couvre chaque scénario d'annulation dans Git. Le point clé à retenir : presque rien n'est vraiment perdu dans Git. Entre restore, reset, revert, stash et reflog, il y a toujours un moyen de revenir à un état correct. Fais défiler pour voir un comparatif côte à côte de toutes les méthodes.