Aller au contenu principal

Annuler des modifications Git : le guide complet

Une erreur ? Un commit trop hâtif ? Un bug en production ? Git dispose d'une commande pour chaque scénario d'annulation. Ce guide t'accompagne à travers toutes les options, du désindexage d'un fichier à la récupération de commits perdus.

GitQuest
Démo

Par Anaïs Sparesotto, développeuse web et responsable pédagogique · Mis à jour le

Référence complète

Six commandes Git, une pour chaque scénario d'annulation. Suis l'arbre de décision pour trouver la bonne commande, puis apprends-la en détail avec des exemples dans le terminal.

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.

Non indexé, non commité

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

Indexé, non commité

Fichiers ajoutés à la zone d'indexation

Tu as lancé git add mais tu n'as pas encore commité.

Utilise git restore --staged

Commité, non pushé

Commits locaux uniquement

Tu as commité mais les modifications sont encore sur ta machine.

Utilise git reset

Commité et pushé

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

Besoin de mettre en pause

Mettre de côté temporairement

Tu veux mettre de côté ton travail en cours et y revenir plus tard.

Utilise git stash

Commit perdu

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.

Comparatif : toutes les méthodes d'annulation Git

Un comparatif détaillé de quand utiliser chaque commande, ce qu'elle affecte, et si elle est sûre pour les branches partagées.

CommandeAgit surRéécrit l'historiqueSure pour branche partagéeConserve les modificationsIdéal pour
git restoreFichiers du répertoire de travailNonOuiNon — supprime les modificationsAnnuler des modifications locales de fichiers
git cleanFichiers non suivisNonOuiNon — supprime les fichiersSupprimer les fichiers générés ou temporaires
git restore --stagedZone d'indexation (index)NonOuiOui — conserve les modifications dans le répertoire de travailDésindexer des fichiers avant un commit
git reset --softCommitsOuiNonOui — restent indexéesModifier ou fusionner des commits locaux
git reset --mixedCommits + indexationOuiNonOui — restent dans le répertoire de travailReselectionner les fichiers à commiter
git reset --hardCommits + indexation + fichiersOuiNonNon — supprime toutSupprimer complètement des expérimentations locales
git revertCommits (en crée un nouveau)NonOuiOui — le commit original resteAnnuler des commits pushés en toute sécurité
git stashRépertoire de travail + indexationNonOuiOui — sauvegarde dans une pileMettre de côté temporairement du travail
git reflogHistorique de HEAD (lecture seule)NonOuiOui — retrouve les commits perdusRécupérer après des opérations destructives
A

GitQuest est conçu par Anaïs (nouvelle fenêtre), développeuse web et responsable pédagogique, spécialisée en formations tech et accessibilité numérique.

Questions sur l'annulation de modifications dans Git

Maîtrise chaque scénario d'annulation

GitQuest t'entraîne à utiliser restore, reset, revert, stash et reflog dans des situations réalistes. Pratique dans un bac à sable sécurisé, sans risque pour tes vrais projets.